WO2021082665A1

WO2021082665A1 - Data processing method, apparatus, device, and medium

Info

Publication number: WO2021082665A1
Application number: PCT/CN2020/110753
Authority: WO
Inventors: 马凌; 何昌华
Original assignee: 支付宝(杭州)信息技术有限公司
Priority date: 2019-10-30
Filing date: 2020-08-24
Publication date: 2021-05-06
Also published as: CN110781016B; CN110781016A; CN112905365A; CN112905365B

Abstract

Disclosed by the embodiments of the present description are a data processing method, apparatus, device, and medium, the data processing methods comprising: upon receiving a lock request of a thread to be locked, performing interaction between lock data and the thread data of the thread to be locked by means of a shared cache of a processor, and determining according to the lock data whether the lock is occupied; if not, then causing the thread to be locked to be locked; if so, then if the target thread data of the lock thread satisfies a preset condition, enabling the thread to be locked to be locked; and/or, upon receiving an unlock request from the thread occupying the lock, determining, when the thread occupying the lock performs data interaction with the lock by means of the shared cache of the processor before occupying the lock, whether the thread data written in said shared cache has changed; if it has changed, then changing the thread data of the thread that occupies the lock, causing the lock occupying the thread to be unlocked.

Description

Data processing method, device, equipment and medium

Technical field

This application relates to the field of computer technology, and in particular to a data processing method, device, equipment and medium.

Background technique

At present, the memory uses a lock mechanism to control thread access, such as MCS lock, and when the thread acquires the lock, it needs to exchange data with the lock, for example, it needs to exchange the pending value. With the existing lock mechanism, when a thread exchanges data with a lock, it needs to determine which level of cache the lock data to be exchanged is located in, such as L1 (first level cache), L2 (second level cache), and then can go Corresponding cache for data exchange. In addition, when the previous thread wants to unlock, it needs to wait for its own "pointer" data (info.next data) to be filled in by the next thread, and then change the pending value of the next thread, so that the previous thread can Unlock, that is, the next thread can obtain the lock, so that the two threads before and after are bundled together and affect each other; an error in one thread will affect the lock or unlock of the other thread. It can be seen that the existing lock mechanism has a complicated process and low operating efficiency, and thus the execution efficiency of the critical section is low, and the conflict is greater (that is, the thread takes longer). In addition, some existing technologies, such as RTM (Restricted Transactional Memory), can help optimize the performance of critical regions, but they only reduce the granularity of critical regions, which will cause more delays when conflicts occur, and at the same time it is more difficult to implement .

In view of this, a more effective and efficient lock mechanism control scheme is needed.

Summary of the invention

The embodiments of this specification provide a data processing method, device, equipment, and medium to solve the technical problem of how to more effectively and efficiently control the lock mechanism.

In order to solve the above technical problems, the embodiments of this specification are implemented in this way.

The embodiment of this specification provides a data processing method, which includes: when a lock request of a thread to be locked is received, an interaction between lock data and thread data of the thread to be locked is performed through the shared cache of the processor, according to the lock data Determine whether the lock is occupied; if not, enable the thread to be locked to obtain the lock; if so, when the target thread data of the thread that occupies the lock meets a preset condition, enable the thread to be locked to obtain the lock; and/or When receiving the unlock request of the lock-occupiing thread, it is determined whether the thread data written into the shared cache is changed when the thread-occupying thread performs data interaction with the lock through the shared cache of the processor before occupying the lock; Change, then change the thread data of the lock-occupying thread to unlock the lock-occupying thread.

The embodiment of this specification provides a data processing method, which includes: when a lock acquisition request of a first thread is received, determining whether a lock is occupied according to data corresponding to the first data of the first thread, and determining whether the lock is occupied or not. The first data is written into the cache line of the lock in the shared cache of the processor; if not, the first thread is allowed to acquire the lock; if so, when the target thread data of the lock thread meets the preset condition, all The first thread acquires the lock; upon receiving the unlock request of the first thread, it is determined whether the first data exists in the shared cache; if it does not exist, the first data of the first thread is changed , Unlock the first thread; if it exists, change the first data in the shared cache to unlock the first thread.

The embodiment of this specification provides a data processing device, including: a lock module, which is used to perform the interaction between lock data and thread data of the thread to be locked through the shared cache of the processor when receiving the lock request of the thread to be locked , Determine whether the lock is occupied according to the lock data; and, if the lock is not occupied, make the thread to be locked obtain the lock; if the lock is occupied, when the target thread data of the lock thread meets the preset condition , Enabling the thread to be locked to obtain the lock; and/or, the unlocking module, when receiving the unlock request of the thread occupying the lock, determine that the thread occupying the lock performs data interaction with the lock through the shared cache of the processor before the thread occupying the lock When the thread data written to the shared cache is changed; and, if the thread data written to the shared cache is changed during the interaction, change the thread data of the thread that occupies the lock so that all The account lock thread is unlocked.

The embodiment of this specification provides a data processing device, including: a lock module, which is used to determine whether the lock is locked according to the data corresponding to the first data of the first thread when the lock acquisition request of the first thread is received. Occupied, and write the first data into the cache line of the lock in the shared cache of the processor; and, if the lock is not occupied, enable the first thread to obtain the lock; if the lock is occupied, it will be occupied When the target thread data of the lock thread meets a preset condition, the first thread acquires the lock; the unlock module is configured to determine whether the first thread exists in the shared cache when the unlock request of the first thread is received. Data; and, if the first data does not exist, change the first data of the first thread to unlock the first thread; and, if the first data exists, then The first data in the shared cache is changed to unlock the first thread.

The embodiment of this specification provides a data processing device, including: at least one processor; and, a memory communicatively connected with the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor , The instruction is executed by the at least one processor, so that the at least one processor can: when receiving a lock request of the thread to be locked, lock data and the thread of the thread to be locked through the shared cache of the processor For data interaction, determine whether the lock is occupied according to the lock data; if not, enable the thread to be locked to obtain the lock; if so, when the target thread data of the lock thread meets a preset condition, the thread to be locked The lock-acquiring thread obtains the lock; and/or, upon receiving the unlock request of the lock-occupying thread, when it is determined that the lock-occupying thread interacts with the lock through the shared cache of the processor before the lock-occupying thread, the data is written to the shared cache Whether the thread data of is changed; if it is changed, change the thread data of the lock-occupying thread to unlock the lock-occupying thread.

The embodiment of this specification provides a data processing device, including: at least one processor; and, a memory communicatively connected with the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor , The instruction is executed by the at least one processor, so that the at least one processor can: when receiving the lock request of the first thread, determine according to the lock data corresponding to the first data of the first thread Whether the lock is occupied, and the first data is written into the cache line of the lock in the shared cache of the processor; if not, the first thread is made to acquire the lock; if it is, the target thread of the thread that occupies the lock When the data meets a preset condition, the first thread is made to acquire the lock; when the unlock request of the first thread is received, it is determined whether the first data exists in the shared cache; if it does not exist, the first data is changed. The first data of the first thread unlocks the first thread; if it exists, the first data in the shared cache is changed to unlock the first thread.

The embodiments of this specification provide a computer-readable storage medium, the computer-readable storage medium stores computer-executable instructions, and when the computer-executable instructions are executed by a processor, the following steps are implemented: When a lock request is made, the interaction between the lock data and the thread data of the thread to be locked is performed through the shared cache of the processor, and it is determined whether the lock is occupied according to the lock data; if not, the thread to be locked is made to obtain the lock; If yes, when the target thread data of the lock-occupying thread meets the preset condition, the thread to be locked is allowed to obtain the lock; and/or, when the unlock request of the lock-occupying thread is received, it is determined that the lock-occupiing thread is before the When performing data interaction with the lock through the shared cache of the processor, whether the thread data written in the shared cache is changed; if it is changed, the thread data of the lock-occupying thread is changed to unlock the lock-occupying thread .

The embodiments of this specification provide a computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the following steps are implemented: When a lock is requested, determine whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread, and write the first data into the cache line of the lock in the shared cache of the processor; if not , The first thread is made to acquire the lock; if so, when the target thread data of the lock thread meets the preset condition, the first thread is made to acquire the lock; when the unlock request of the first thread is received, it is determined Whether the first data exists in the shared cache; if it does not exist, the first data of the first thread is changed to unlock the first thread; if it exists, the first data in the shared cache is changed The first data unlocks the first thread.

The above-mentioned at least one technical solution adopted in the embodiment of this specification can achieve the following beneficial effects: in the lock mechanism control process, data exchange is performed through the shared cache, which can avoid the complicated migration of lock redundancy, accelerate the execution of critical regions, and reduce the occurrence of conflicts. , At the same time, it avoids rollback during the conflict, which can simplify the lock control process and improve the lock control efficiency.

Description of the drawings

In order to more clearly describe the technical solutions in the embodiments of this specification, the following will briefly introduce the drawings that need to be used in the description of the embodiments of this specification. Obviously, the drawings in the following description are only some of the descriptions in this specification. Embodiments, for those of ordinary skill in the art, without creative work, other drawings can be obtained based on these drawings.

Fig. 1 is a schematic flow chart of the data processing method in the first embodiment of this specification.

Fig. 2 is a schematic diagram of the application of the data processing method in the first embodiment of this specification.

Fig. 3 is a schematic diagram of the locking process in the first embodiment of this specification.

Figure 4 is a schematic flow chart of the data processing method in the second embodiment of this specification

Fig. 5 is a schematic diagram of the unlocking process in the second embodiment of this specification.

Fig. 6 is a schematic flow chart of the data processing method in the third embodiment of this specification.

FIG. 7 is a schematic diagram of the structure of the data processing device in the fourth embodiment of this specification.

Fig. 8 is a schematic diagram of the structure of the data processing device in the fifth embodiment of this specification.

Detailed ways

In order to enable those skilled in the art to better understand the technical solutions in this specification, the following will clearly and completely describe the technical solutions in the embodiments of this specification in conjunction with the drawings in the embodiments of this specification. Obviously, the described The embodiments are only a part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments of this specification, all other embodiments obtained by a person of ordinary skill in the art without creative work shall fall within the protection scope of this application.

The more commonly used MCS lock operation process is: thread has two variables: info.next (pointer) and info.pending. When a thread (maybe referred to as thread A) wants to acquire a lock, thread A interacts with the lock and reads Get the lock data and write your own data into the lock cache line; judge whether the lock is occupied according to the read lock data; if it is not occupied, thread A obtains the lock; if it is occupied, because of the thread currently occupying the lock ("Lock thread" for short) also has data interaction with the lock, thread A obtains the private data address of the thread currently occupying the lock through the read lock data, and then fills its own private data address into the info of the thread currently occupying the lock .next variable, and wait for the current lock thread to change the info.pending value of thread A (the lock thread obtains the private data address of thread A through the info.next variable, and then can change the data of thread A); If the value of info.pending is changed, the lock thread is unlocked, and thread A can obtain the lock.

When a lock-occupying thread (maybe denoted as thread B) needs to be unlocked, you need to determine whether the data written in the cache line of the lock has been changed when you interact with the lock before occupying the lock; if not, it means that no other threads want to acquire the lock. Then clear the data written in the cache line of the lock when interacting with the lock before occupying the lock, and thread B unlocks; if it is, it means that other threads are applying for the lock (other threads acquiring the lock will interact with the lock data, and other threads writing to the lock cache The data of the line will overwrite the data written by the thread B to the lock cache line), only when the info.next variable of thread B is written by other threads, you can use info.next to determine the data address of the thread you want to acquire the lock, and then change the thought The info.pending value of the thread that wants to acquire the lock, so that thread B is unlocked and other threads acquire the lock.

It can be seen from the above that the two threads that want to acquire the lock are bundled together and affect each other. Only the latter thread writes its own data address to the info.next of the previous thread, and the previous thread changes the next thread’s When the value of info.pending is set, the former thread can unlock, and the latter thread can acquire the lock. If one of them fails, the lock mechanism cannot operate.

The processor has a private cache and a shared cache. Among them, the data read by each processor core of the processor can be written into the shared cache, and each processor core can also read the data in the shared cache. Each processor core has its own private cache. For any processor core, the data in the private cache of the processor core cannot be read by other processor cores, and other processor cores cannot write data to the process. In the private cache of the processor core. In the prior art, for any thread, when it wants to acquire a lock and interacts with the lock, it will migrate the lock data to a certain level of private cache of its corresponding processor core, so that it is convenient for the next time it wants to acquire it. Data interaction with the lock during lock. In this way, the next thread that wants to acquire the lock wants to interact with the lock. It must first ask the shared cache to determine which level of cache of which processor core the lock data is located, and then the shared cache sends the lock data to the The processor core issues an instruction to send the lock data to the processor core corresponding to "the next thread that wants to acquire a lock", and the processor core corresponding to the next thread that wants to acquire a lock will The lock data is stored in its own private cache, so that "the next thread that wants to acquire the lock" interacts with the lock in its own private cache (also for the convenience of data exchange with the lock the next time you want to acquire the lock) Interaction). In view of this, the existing lock mechanism process is complicated, and the lock data needs to be continuously migrated, so the operation efficiency is low, the execution efficiency of the critical section is low, and the conflict is greater.

As shown in Figure 1, the first embodiment of this specification provides a data processing method. The execution body of this embodiment may be a computer or a server or a corresponding data processing system or a shared cache control unit, that is, the execution body may be diverse and can be set or changed according to actual conditions. In addition, there may also be a third-party application program to assist the execution subject in executing this embodiment; for example, as shown in FIG. 2, the data processing method in this embodiment may be executed by the server, and the data processing method in this embodiment may also be executed in (owned by the user) The corresponding application program is installed on the terminal (including but not limited to mobile phone and computer). The server corresponds to the application program. Data can be transmitted between the server and the terminal held by the user. The application program is used to display pages and information to the user. input Output.

As shown in Fig. 1, the data processing method in this embodiment includes steps S101 to S103.

S101: When receiving the lock request of the thread to be locked, perform the interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor, and determine whether the lock is occupied according to the lock data.

In this embodiment, a lock acquisition request from any thread (may be denoted as thread C) is received (thread C may be referred to as a "thread to be locked", and a lock acquisition request may be referred to as a "lock request") After that, the thread data of thread C and the lock data need to be interacted (or exchanged). In particular, the thread data and the lock data are interacted through the shared cache (which can be the shared cache of the processor), that is, the lock data (the lock data can be set to 16 bytes or more) is stored in the shared cache. Among them, the shared cache may be the last level cache (Last Level Cache, LLC), so the execution subject may be the control unit of the last level cache.

In this embodiment, thread C carries corresponding data, and the data it carries includes but is not limited to the private data address of thread C and private data (that is, the content of the private data). The private data can be the pending value (or flag bit value) of thread C. The pending value can be initially 0 by default and can be changed. In addition, both the private data address and the private data can be 8 bytes or more. In addition, an initialization structure struct mcs_info{long pending; /*8 bytes*/} can be set for thread C.

The thread data of thread C used to interact with the lock data (the thread data used to interact with the lock data is referred to as "thread interaction data") includes but is not limited to the above private data address and private data, that is, The private data address and the private data are organized into thread interaction data. For example, value=&info.pending<<64|info.pending can be used to form thread interaction data, which is not limited in this embodiment. The thread interaction data and the lock data used to interact with the thread interaction data (the lock data used to interact with the thread interaction data will be referred to as "lock interaction data" hereinafter) have the same bytes. The initial content of the lock interaction data can be empty.

The interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor includes: on the one hand, the lock interaction data is read from the shared cache, and the read lock interaction data is returned to the pipeline corresponding to thread C (ie thread The pipeline of the processor where C is located); on the other hand, the thread interaction data of thread C is written into the cache line of the lock in the shared cache, that is, the thread interaction data of thread C is used to overwrite the lock interaction data in the shared cache. Specifically, old=XCHG_OPT(&lock,&value) can be used for data interaction (old is lock interaction data), which is not limited in this embodiment. Thread interaction data belongs to thread data, lock interaction data belongs to lock data, and the interaction between thread interaction data and lock interaction data is the interaction between thread data and lock data.

In this embodiment, it can be determined whether the lock is occupied according to the lock interaction data. Specifically, determining whether the lock is occupied according to the lock interaction data may include: if the lock interaction data is empty (for example, the lock data is still in the initialized state and has not been changed; or although it has been changed, it returns to the empty state) , The lock is not occupied; if the lock interaction data is not empty (indicating that before receiving the lock request of the thread to be locked, the data interaction between the thread and the lock through the shared cache has occurred, so that The “lock interaction data of the lock thread interaction” becomes “the thread interaction data of the last thread interacting with the lock”), then the lock is occupied.

S103: If the lock is not occupied, enable the thread to be locked to obtain the lock; if the lock is occupied, when the target thread data of the thread that occupies the lock meets a preset condition, enable the thread to be locked Get the lock.

If the lock is not occupied when the lock request of thread C is received, thread C is allowed to obtain the lock; if the lock is already occupied when the lock request of thread C is received, then the thread that occupies the lock (that is, the thread that occupies the lock) When the target thread data of) meets the preset condition, the thread C obtains the lock, as shown in Figure 3. Among them, for any thread, the target thread data of the thread belongs to the "thread data used for data interaction with the lock", that is, it belongs to the "thread interaction data of the thread". Specifically, the target thread data may be the thread's pending value (private data), that is, info.pending. In this embodiment, when the target thread data of the lock thread is greater than the lock interaction data obtained by the thread to be locked, the target thread data of the lock thread meets the preset condition. Specifically, the lock interaction data obtained by the thread to be acquired includes the pending value of the lock thread. If the "pending value of the lock thread (target thread data)" is greater than the amount of the lock interaction data obtained by the thread to be locked The pending value of the lock thread" (the pending value of the occupancy thread in the lock interaction data obtained by the lock thread to be acquired is the value of the lock interaction data obtained by the lock thread that corresponds to the target thread data of the occupant thread Data”), it can be considered that the target thread data of the lock thread is greater than the lock interaction data (obtained by the thread to be locked), and it can be considered that the target thread data of the lock thread is greater than the lock data (the lock interaction data belongs to the lock data).

After the thread C obtains the lock, it can enter the critical area (or critical area) to perform corresponding operations, such as modifying global variables, which is not limited in this embodiment.

When any thread wants to acquire the lock, it can perform the above process, and exchange data with the lock through the shared cache. Therefore, the shared cache in this embodiment may be shared by any number of threads. For different threads to be locked, the locked data does not need to be migrated in the shared cache.

As shown in Fig. 4, the second embodiment of this specification provides a data processing method, including steps S105 to S107.

S105: When receiving the unlock request of the lock-occupiing thread, determine whether the thread data written in the shared cache is changed when the thread-occupying thread performs data interaction with the lock through the shared cache of the processor before the lock-occupiing thread.

When the thread obtains the lock and performs the corresponding operation, it will receive the thread's unlock request. Assuming that thread D is a lock thread, thread D will also execute the aforementioned S101 and S103 during the process from the thread to be locked to the lock thread, so thread D will also interact with the lock in the shared cache. When receiving the unlock request of thread D, when it is determined that thread D interacts with the lock through the shared cache before occupying the lock, the thread interaction data of thread D written in the shared cache (the thread interaction data of thread D written to the shared cache is also Whether the lock interaction data used for data interaction with the next thread to be locked after thread D is changed.

S107: If the thread data written into the shared cache is changed, the thread data of the lock-occupying thread is changed to unlock the lock-occupiing thread.

When the unlock request of thread D is received, if the thread interaction data of thread D written in the shared cache is changed, it means that after thread D, the lock request of other threads (maybe denoted as thread E) is also received, and occurs The interaction between the thread interaction data of thread E and the lock interaction data, so that the lock interaction data in the shared cache (that is, the thread interaction data of thread D) is changed to the thread interaction data of thread E (the private data addresses of two different threads are different , So the thread interaction data of two different threads is different). In this way, the thread data of thread D is changed, specifically the thread interaction data of thread D, and more specifically the target thread data of thread D (the target thread data is the same as above), so that thread D as the lock owner is unlocked and thread D leaves The critical area is shown in Figure 5. In this embodiment, changing the thread interaction data of the thread may include: adding 1 to the pending value of the thread, which may be expressed as private data address->private data=private data address->private data+1.

When receiving the unlock request of thread D, if the thread interaction data of thread D written in the shared cache is not changed thread D, it means that there is no other thread between thread D interacting with the lock data and receiving the unlock request of thread D Data interaction with the lock, that is, no other thread applies for the lock. In this way, the thread interaction data of thread D in the shared cache is changed, so that the lock-occupying thread is unlocked. Changing the thread interaction data of the thread D in the shared cache may include: writing the thread interaction data of the thread D in the shared cache to be empty (empty). When the next thread wants to acquire the lock, it will find that the lock interaction data is empty, so that the next thread can acquire the lock. As shown in Figure 5.

When any thread wants to unlock, it can perform the above process, and perform data interaction with the lock through the shared cache. Therefore, the shared cache in this embodiment may be shared by any number of threads. For different threads occupying the lock, the locked data does not need to be migrated in the shared cache.

The first and second embodiments will be further described below by taking thread X and thread Y as examples.

Assuming that the lock acquisition request of the receiving thread Y is earlier than the lock acquisition request of the receiving thread X, when the lock acquisition request of the thread X is received, the thread interaction data of the thread X and the lock interaction data are interacted. Then:

(1) If the lock request of receiving thread X is later than the unlock request of receiving thread Y, when receiving the unlock request of thread Y, thread X has not yet interacted with the lock, and the thread interaction data of thread Y written to the shared cache is not If it is changed, the thread interaction data of thread Y written in the shared cache is cleared. In this way, when receiving the lock request of thread X, the thread interaction data of thread X is interacted with the lock interaction data, the lock interaction data is read from the shared cache, and the read lock interaction data is empty, indicating that the lock is not Occupied, thread X acquires the lock.

(2) If the lock request of the receiving thread X is earlier than the unlock request of the receiving thread Y, when the lock request of the thread X is received, the lock is at least occupied by the thread Y (thread Y is the lock thread). Because thread Y also performs the process of this embodiment, that is, when receiving the lock request of thread X or before receiving the lock request of thread X, it has already received the lock request of thread Y, and thread interaction data of thread Y has occurred. Interaction with lock interaction data, the lock interaction data used for interaction with thread X in the shared cache has been overwritten with thread interaction data of thread Y (this is the same as the above "If the lock interaction data is not empty, the lock is occupied" Echoes).

When receiving the lock request of thread X, the thread interaction data of thread X is interacted with the lock interaction data through the shared cache, and the lock interaction data (lock interaction data is thread interaction data of thread Y) is read from the shared cache and released Enter the pipeline corresponding to thread X, so that thread X can obtain thread interaction data of thread Y, including the private data address and private data of thread Y, and the lock interaction data used for interaction with other threads in the shared cache is changed to thread X The thread interacts with data.

Thread X can wait for the thread interaction data of thread Y to be changed (because the lock request of receiving thread X is earlier than the unlock request of receiving thread Y. When the unlock request of thread Y is received, it will find the thread Y that writes to the shared cache. The thread interaction data has been changed to the thread interaction data of thread X, which will change the thread data of thread Y, specifically the thread interaction data of thread Y). In particular, thread X can use while (private data address of thread Y -> private data of thread Y <= private data of thread Y obtained by thread X) to wait; among them, while (private data address of thread Y -> The private data of thread Y <= the private data of thread Y obtained by thread X) means that if the private data of thread Y is less than or equal to "the private data of thread Y obtained by thread X", thread X waits. Since the private data address of thread Y can be read from the shared cache, thread X or the executive body can (continuously or regularly) obtain the private data of thread Y through the private data address of thread Y, and then can compare (continuously or regularly) The size relationship between the private data of thread Y and the “private data of thread Y obtained by thread X”.

Because when receiving the unlock request of thread Y, the thread interaction data of thread Y will be changed, that is, the pending value of thread Y is increased by 1, then the target thread data of the lock thread is greater than the lock interaction data obtained by thread X, that is, thread Y’s thread interaction data The private data is greater than "the private data of thread Y obtained by thread X", so that on the one hand thread Y is unlocked, on the other hand, while (the private data address of thread Y -> the private data of thread Y <= thread Y obtained by thread X Private data) is no longer satisfied, so that thread X obtains the lock.

The aforementioned threads A, B, C, D, E, X, and Y do not specifically refer to a certain thread, but can refer to any thread.

The above-mentioned embodiments can be used alone or in combination or in combination.

The above embodiment discloses a new data processing method that can be used for lock mechanism control. In the process of lock mechanism control, the data exchange between threads and locks is carried out through the shared cache (because thread interaction data is written to the shared cache, the lock interaction data is from Shared cache reads, so it is equivalent to the data exchange between threads and locks in the shared cache), the lock data does not need to be migrated between the various processor cores, that is, the redundant and complex migration of lock data is avoided, so that threads and locks Data interaction is shorter, more efficient, and more efficient in thread processing. In the above embodiment, in order to unlock the lock-occupiing thread or enable other threads to obtain the lock, the thread interaction data of the lock-occupiing thread or the thread interaction data in the shared cache can be changed (the thread interaction data in the shared cache is actually the lock interaction Data), and the thread or execution subject to be locked can obtain the private data address of the lock thread through the data interaction between the lock thread and the lock, and then obtain the thread interaction data change (private data change) of the lock thread, so that the lock is occupied When a thread is unlocked, it does not need to monitor or take into account the data changes of other threads, and it does not need to operate on the data of other threads. It can be seen that the above embodiments can speed up the execution of critical regions and reduce thread time consumption; can simplify the lock control process, improve lock control efficiency and thread processing efficiency; can reduce the occurrence of conflicts, and avoid rollbacks in the process of conflicts.

As shown in FIG. 6, the third embodiment of this specification provides a data processing method, and the execution subject of this embodiment can refer to the first embodiment. The data processing method of this embodiment includes S201 to S207.

S201: When receiving the lock acquisition request of the first thread, determine whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread, and write the first data into the shared cache of the processor The cache line of the lock.

In this embodiment, the first thread can be equivalent to the thread C in the first embodiment, and the first data can be equivalent to the thread interaction data in the first embodiment. The “corresponding” data can be equivalent to the lock interaction data in the first embodiment, according to the data corresponding to the first data of the first thread (that is, the first data of the read lock and the first thread of the first thread). Corresponding data) determining whether the lock is occupied may be equivalent to determining whether the lock is occupied according to the lock interaction data in the first embodiment.

S203: If the lock is not occupied, let the first thread acquire the lock; if the lock is occupied, when the target thread data of the occupied thread meets a preset condition, let the first thread acquire the lock.

For details, please refer to the first embodiment.

The "target thread data" in this embodiment is the same as the "target thread data" in the first embodiment.

S205: When receiving the unlock request of the first thread, determine whether the first data exists in the shared cache.

See the first embodiment.

S207: If the first data does not exist in the shared cache, modify the first data of the first thread to unlock the first thread; if the first data exists in the shared cache, modify the shared cache. The first data in the cache unlocks the first thread.

See the first embodiment.

In this embodiment, the second thread is a thread that wants to acquire a lock after the first thread, that is, receiving the lock request of the second thread is later than receiving the lock request of the first thread. When receiving the lock request of the second thread, determine whether the lock is occupied according to the data of the lock "corresponding to the second data of the second thread", and write the second data to the shared cache. The cache line of the lock; if not, the second thread is made to acquire the lock; if so, the second thread is made to acquire the lock when the first data meets a preset condition. The second data is equivalent to the thread interaction data of the second thread.

In this embodiment, when the unlock request of the second thread is received, it is determined whether the second data exists in the cache line; if it does not exist, the second data of the second thread is changed so that The second thread is unlocked. And/or, when receiving the unlock request of the second thread, determine whether the second data exists in the cache line; if so, change the second data in the shared cache so that the second data The thread is unlocked.

In this embodiment, if the receiving of the lock request of the second thread is earlier than the receiving of the unlock request of the first thread, the data corresponding to the second data of the lock is the first data; and /Or, if the receiving of the lock request of the second thread is later than the receiving of the unlock request of the first thread, the data corresponding to the second data of the lock is the data in the shared cache. The data after the first data is changed.

In this embodiment, determining whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread includes: if the data of the lock corresponding to the first data of the first thread is empty, the The lock is not occupied; if the data corresponding to the first data of the first thread of the lock is not empty, the lock is occupied.

In this embodiment, for any data (not limited), if the data is greater than the corresponding lock data, the data meets the preset condition. Then when the target thread data of the lock thread is greater than the corresponding lock data, the target thread data of the lock thread meets the preset condition; when the first data is greater than the corresponding lock data, the first data meets the preset condition.

In this embodiment, the target thread data belongs to data used by the lock-holding thread to write to the shared cache.

In this embodiment, the shared cache is the last level cache.

In this embodiment, the first data includes the private data address and private data of the first thread.

In this embodiment, the first data is the pending value of the first thread.

In this embodiment, changing the first data of the first thread includes: adding 1 to the pending value of the first thread.

In this embodiment, the second data is the pending value of the second thread.

In this embodiment, changing the second data of the second thread includes: adding 1 to the pending value of the second thread.

In this embodiment, changing the first data in the shared cache includes: writing the first data in the cache line as empty.

In this embodiment, changing the second data in the shared cache includes: writing the second data in the cache line as empty.

For content not described in detail in this embodiment, reference may be made to the first embodiment.

In this embodiment, the first thread and the second thread do not specifically refer to a certain thread, but may refer to any thread.

This embodiment discloses a new data processing method that can be used for lock mechanism control. In the lock mechanism control process, lock data reading and thread data writing are performed through the shared cache (the first data or the second data is written to and shared Cache, the lock data corresponding to it is read from the shared cache, so it is equivalent to reading and writing data in the shared cache), avoiding the redundant and complicated migration of lock data; in this embodiment, in order to unlock or unlock the lock thread To enable other threads to acquire the lock, you can change the data that occupies the lock thread (such as the first data or the second data) or change the thread data in the shared cache (such as the first data or the second data). Thread interaction data), and the thread to be locked or the execution subject can obtain the private data address of the lock thread through the data interaction between the lock thread and the lock, and then obtain the thread data change (private data change) of the lock thread. When the lock-occupiing thread is unlocked, it does not need to monitor or take into account the data changes of other threads, and it does not need to operate on the data of other threads. It can be seen that the above embodiment can speed up the execution of the critical section and reduce thread time consumption; can simplify the lock control process and improve the lock control efficiency; can reduce the occurrence of conflicts and avoid rollbacks in the process of conflicts.

As shown in FIG. 7, the fourth embodiment of this specification provides a data processing device, which includes a locking module 301 and an unlocking module 303.

The locking module 301 (or the first locking module 301) is used to perform the interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor when receiving the lock request of the thread to be locked. The lock data determines whether the lock is occupied; and, if the lock is not occupied, the thread to be locked obtains the lock; if the lock is occupied, when the target thread data of the lock thread meets the preset condition, the thread The thread to be locked acquires the lock.

The unlocking module 303 (or the first unlocking module 303) is configured to, when receiving an unlocking request of the lock-occupying thread, determine that the lock-occupying thread performs data interaction with the lock through the shared cache of the processor before the lock-occupying thread, and writes the Whether the thread data in the shared cache is changed; and, if the thread data written to the shared cache is changed during the interaction, the thread data of the lock-occupiing thread is changed to unlock the lock-occupiing thread.

Optionally, the unlocking module 303 is further configured to: when receiving an unlock request from the lock-occupiing thread, if the lock-occupying thread interacts with the lock through the shared cache before occupying the lock, write to the shared cache If the thread data has not been changed, the thread data in the shared cache is changed to unlock the lock thread.

Optionally, performing the interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor includes: reading the lock data for interaction from the shared cache and putting it into the pipeline corresponding to the thread; and The thread data used for interaction is written into the cache line of the lock in the shared cache.

Optionally, determining whether the lock is occupied according to the lock data includes: if the lock data is empty, the lock is not occupied; if the lock data is not empty, the lock is occupied.

Optionally, when the target thread data occupying the lock thread is greater than the lock data, the target thread data meets a preset condition.

Optionally, the target thread data belongs to thread data used by the lock-holding thread for data interaction with the lock.

Optionally, the shared cache is the last level cache.

Optionally, the thread data includes a private data address and private data of the thread.

Optionally, the private data is the pending value of the thread.

Optionally, changing the thread data of the thread includes: adding 1 to the pending value of the thread.

Optionally, changing the thread data in the shared cache includes: writing the thread data written in the shared cache during the interaction to be empty.

As shown in FIG. 8, the fifth embodiment of this specification provides a data processing device, which includes a locking module 401 and an unlocking module 403.

The locking module 401 (or the second locking module 401) is used to determine whether the lock is occupied according to the data corresponding to the first data of the first thread when receiving the lock request of the first thread, and Write the first data to the cache line of the lock in the shared cache of the processor; and, if the lock is not occupied, enable the first thread to obtain the lock; if the lock is occupied, then the thread of the lock is occupied When the target thread data meets the preset condition, the first thread is made to acquire the lock.

The unlocking module 403 (or the second unlocking module 403) is configured to determine whether the first data exists in the shared cache when receiving the unlock request of the first thread; and, if the first data does not exist, Data, the first data of the first thread is changed to unlock the first thread; and, if the first data exists, the first data in the shared cache is changed so that The first thread is unlocked.

Optionally, the locking module 401 is further configured to: when receiving a lock request from the second thread, determine whether the lock is occupied according to the data corresponding to the second data of the second thread, and to set the lock The second data is written into the cache line of the lock in the shared cache; if not, the second thread is allowed to acquire the lock; if so, when the first data meets a preset condition, the The second thread acquires the lock.

Optionally, the unlocking module 403 is further configured to: when receiving the unlocking request of the second thread, determine whether the second data exists in the cache line; if it does not exist, change the second thread The second data of the unlocking of the second thread. And/or, when receiving the unlock request of the second thread, determine whether the second data exists in the cache line; if so, change the second data in the shared cache so that the second data The thread is unlocked.

Optionally, if receiving the lock request of the second thread is earlier than receiving the unlock request of the first thread, the data corresponding to the second data of the lock is the first data; and/ Or, if the receiving of the lock request of the second thread is later than the receiving of the unlock request of the first thread, the data corresponding to the second data of the lock is the first data in the shared cache. The data after the data has been changed.

Optionally, determining whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread includes: if the data of the lock corresponding to the first data of the first thread is empty, the lock Unoccupied; if the data corresponding to the first data of the first thread of the lock is not empty, the lock is occupied.

Optionally, for any data (not limited), if the data is greater than the corresponding lock data, the data meets the preset condition. Then when the target thread data of the lock thread is greater than the corresponding lock data, the target thread data of the lock thread meets the preset condition; when the first data is greater than the corresponding lock data, the first data meets the preset condition.

Optionally, the target thread data belongs to data used by the lock-holding thread to write to the shared cache.

Optionally, the shared cache is the last level cache.

Optionally, the first data includes a private data address and private data of the first thread.

Optionally, the first data is a pending value of the first thread.

Optionally, changing the first data of the first thread includes: adding 1 to the pending value of the first thread.

Optionally, the second data is a pending value of the second thread.

Optionally, changing the second data of the second thread includes: adding 1 to the pending value of the second thread.

Optionally, changing the first data in the shared cache includes: writing the first data in the cache line as empty.

Optionally, changing the second data in the shared cache includes: writing the second data in the cache line as empty.

A sixth embodiment of the present specification provides a data processing device, including: at least one processor; and, a memory communicatively connected to the at least one processor; wherein the memory stores the memory that can be used by the at least one processor; The executed instruction, which is executed by the at least one processor, enables the at least one processor to: when receiving a lock request from the thread to be locked, lock data and lock data through the processor’s shared cache The thread data interaction of the thread determines whether the lock is occupied according to the lock data; if not, the thread to be locked obtains the lock; if so, when the target thread data of the lock thread meets the preset condition, The thread to be locked acquires the lock; when receiving an unlock request from the lock-occupying thread, it is determined that when the lock-occupying thread interacts with the lock through the shared cache of the processor before acquiring the lock, the data written to the shared cache is Whether the thread data is changed; if it is changed, the thread data of the lock-occupiing thread is changed to unlock the lock-occupiing thread.

A seventh embodiment of the present specification provides a data processing device, including: at least one processor; and, a memory communicatively connected with the at least one processor; wherein the memory stores the memory that can be used by the at least one processor; An instruction executed by the at least one processor to enable the at least one processor to: upon receiving the lock request of the first thread, according to the lock corresponding to the first data of the first thread Determine whether the lock is occupied, and write the first data to the cache line of the lock in the shared cache of the processor; if not, make the first thread acquire the lock; if so, then the thread will be occupied When the target thread data of the target thread meets the preset condition, the first thread is allowed to acquire the lock; when the unlock request of the first thread is received, it is determined whether the first data exists in the shared cache; if it does not exist, then Modify the first data of the first thread to unlock the first thread; if it exists, modify the first data in the shared cache to unlock the first thread.

The eighth embodiment of the present specification provides a computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the following steps are implemented: When a lock request is made by a lock thread, the lock data is interacted with the thread data of the thread to be locked through the shared cache of the processor, and it is determined whether the lock is occupied according to the lock data; if not, the thread to be locked is made Acquire the lock; if so, when the target thread data of the lock-occupying thread meets the preset condition, the thread to be locked is allowed to obtain the lock; when the unlock request of the lock-occupiing thread is received, it is determined that the lock-occupying thread passes before the lock is occupied When the shared cache of the processor interacts with the lock, whether the thread data written in the shared cache is changed; if it is changed, the thread data of the lock occupying thread is changed to unlock the lock occupying thread.

The ninth embodiment of the present specification provides a computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the following steps are implemented: When a thread acquires a lock request, determine whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread, and write the first data into the cache line of the lock in the shared cache of the processor If not, make the first thread acquire the lock; if yes, make the first thread acquire the lock when the target thread data of the lock thread meets the preset condition; receive the unlock request of the first thread When, determine whether the first data exists in the shared cache; if it does not exist, modify the first data of the first thread to unlock the first thread; if it exists, modify the first data in the shared cache. The first data of the unlocking of the first thread.

The above embodiments can be used in combination.

The specific embodiments of this specification have been described above, and other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims may be performed in a different order than in the embodiments and still achieve desired results. In addition, the processes depicted in the drawings do not necessarily have to be in the specific order or sequential order shown in order to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the device, equipment, and non-volatile computer-readable storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and for related parts, please refer to the part of the description of the method embodiments.

The apparatus, equipment, non-volatile computer readable storage medium and method provided in the embodiments of this specification correspond to each other. Therefore, the apparatus, equipment, and non-volatile computer storage medium also have beneficial technical effects similar to the corresponding method. The beneficial technical effects of the method have been described in detail above, therefore, the beneficial technical effects of the corresponding device, equipment, and non-volatile computer storage medium will not be repeated here.

In the 1990s, the improvement of a technology can be clearly distinguished between hardware improvements (for example, improvements in circuit structures such as diodes, transistors, switches, etc.) or software improvements (improvements in method flow). However, with the development of technology, the improvement of many methods and processes of today can be regarded as a direct improvement of the hardware circuit structure. Designers almost always get the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be realized by the hardware entity module. For example, a programmable logic device (Programmable Logic Device, PLD) (for example, a Field Programmable Gate Array (Field Programmable Gate Array, FPGA)) is such an integrated circuit whose logic function is determined by the user's programming of the device. It is programmed by the designer to "integrate" a digital system on a PLD, without requiring the chip manufacturer to design and manufacture a dedicated integrated circuit chip. Moreover, nowadays, instead of manually making integrated circuit chips, this kind of programming is mostly realized by using "logic compiler" software, which is similar to the software compiler used in program development and writing, but before compilation The original code must also be written in a specific programming language, which is called Hardware Description Language (HDL), and there is not only one HDL, but many, such as ABEL (Advanced Boolean Expression) Language), AHDL (Altera Hardware DescrIP address Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware DescrIP address Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Address) Language) and so on, the most commonly used at present are VHDL (Very-High-Speed Integrated Circuit Hardware DescrIP Address Language) and Verilog. It should also be clear to those skilled in the art that only a little logic programming of the method flow in the above-mentioned hardware description languages and programming into an integrated circuit can easily obtain the hardware circuit that implements the logic method flow.

The controller can be implemented in any suitable manner. For example, the controller can take the form of, for example, a microprocessor or a processor and a computer-readable medium storing computer-readable program codes (such as software or firmware) executable by the (micro)processor. , Logic gates, switches, application specific integrated circuits (ASICs), programmable logic controllers and embedded microcontrollers. Examples of controllers include but are not limited to the following microcontrollers: ARC625D, Atmel AT91SAM, MicrochIP addresses PIC18F26K20 and Silicon Labs C8051F320, the memory controller can also be implemented as a part of the memory control logic. Those skilled in the art also know that, in addition to implementing the controller in a purely computer-readable program code manner, it is entirely possible to program the method steps to make the controller use logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded logic. The same function can be realized in the form of a microcontroller, etc. Therefore, such a controller can be regarded as a hardware component, and the devices included in it for realizing various functions can also be regarded as a structure within the hardware component. Or even, the device for realizing various functions can be regarded as both a software module for realizing the method and a structure within a hardware component.

The systems, devices, modules, or units explained in the above embodiments may be implemented by computer chips or entities, or implemented by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cell phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or Any combination of these devices.

For the convenience of description, when describing the above device, the functions are divided into various units and described separately. Of course, when implementing this specification, the functions of each unit can be implemented in the same one or more software and/or hardware.

Those skilled in the art should understand that the embodiments of this specification can be provided as a method, a system, or a computer program product. Therefore, the embodiments of this specification may adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the embodiments of this specification may adopt the form of computer program products implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.

This specification is described with reference to flowcharts and/or block diagrams of methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and/or block in the flowchart and/or block diagram, and the combination of processes and/or blocks in the flowchart and/or block diagram can be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing equipment to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing equipment are generated It is a device that realizes the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

These computer program instructions can also be stored in a computer-readable memory that can guide a computer or other programmable data processing equipment to work in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture including the instruction device. The device implements the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

These computer program instructions can also be loaded on a computer or other programmable data processing equipment, so that a series of operation steps are executed on the computer or other programmable equipment to produce computer-implemented processing, so as to execute on the computer or other programmable equipment. The instructions provide steps for implementing the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

In a typical configuration, the computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include non-permanent memory in a computer readable medium, random access memory (RAM) and/or non-volatile memory, such as read-only memory (ROM) or flash memory (flash RAM). Memory is an example of computer readable media.

Computer-readable media include permanent and non-permanent, removable and non-removable media, and information storage can be realized by any method or technology. The information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, CD-ROM, digital versatile disc (DVD) or other optical storage, Magnetic cartridges, magnetic tape storage or other magnetic storage devices or any other non-transmission media can be used to store information that can be accessed by computing devices. According to the definition in this article, computer-readable media does not include transitory media, such as modulated data signals and carrier waves.

It should also be noted that the terms "include", "include" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or equipment including a series of elements not only includes those elements, but also includes Other elements that are not explicitly listed, or they also include elements inherent to such processes, methods, commodities, or equipment. If there are no more restrictions, the element defined by the sentence "including a..." does not exclude the existence of other identical elements in the process, method, commodity, or equipment that includes the element.

This specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. This specification can also be practiced in distributed computing environments. In these distributed computing environments, tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules can be located in local and remote computer storage media including storage devices.

The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, as for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for related parts, please refer to the part of the description of the method embodiment.

The above descriptions are only examples of this specification, and are not intended to limit this application. For those skilled in the art, this application can have various modifications and changes. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of this application shall be included in the scope of the claims of this application.

Claims

A data processing method, including:

When receiving a lock request of the thread to be locked, interact with the lock data and the thread data of the thread to be locked through the shared cache of the processor, and determine whether the lock is occupied according to the lock data;

If not, enable the thread to be locked to obtain the lock;

If so, when the target thread data of the lock thread meets the preset condition, the thread to be locked is allowed to obtain the lock;

and / or,

When receiving the unlock request of the lock-occupiing thread, determine whether the thread data written in the shared cache is changed when the thread-occupying thread performs data interaction with the lock through the shared cache of the processor before the lock-occupying thread;

If it is changed, the thread data of the lock occupying thread is changed to unlock the lock occupying thread.
The method of claim 1, further comprising:

When receiving the unlock request of the lock-occupying thread, if the thread-occupying thread interacts with the lock through the shared cache before occupying the lock, the thread data written in the shared cache is not changed, then all the data in the shared cache is changed. The thread data enables the lock-occupiing thread to be unlocked.
The method according to claim 1, wherein the interaction of the lock data and the thread data of the thread to be locked through the shared cache of the processor comprises:

Read the lock data for interaction from the shared cache and put it into the pipeline corresponding to the thread; and,

The thread data used for interaction is written into the cache line of the lock in the shared cache.
The method of claim 1, wherein determining whether the lock is occupied according to the lock data comprises:

If the lock data is empty, the lock is not occupied;

If the lock data is not empty, the lock is occupied.
5. The method according to claim 1, when the target thread data occupying the lock thread is greater than the lock data, the target thread data meets a preset condition.
5. The method according to any one of claims 1 to 5, wherein the target thread data belongs to thread data used by the lock-holding thread for data interaction with the lock.
The method according to any one of claims 1 to 5, wherein the shared cache is the last level cache.
5. The method according to any one of claims 1 to 5, the thread data includes a private data address and private data of the thread.
8. The method of claim 8, wherein the private data is a pending value of the thread.
9. The method of claim 9, wherein changing the thread data of the thread comprises:

Add 1 to the pending value of the thread.
The method of claim 2, wherein changing the thread data in the shared cache includes:

The thread data written into the shared cache during the interaction is written as empty.
A data processing method, including:

When receiving the lock request of the first thread, determine whether the lock is occupied according to the data of the lock corresponding to the first data of the first thread, and write the first data into the shared cache of the processor. Locked cache line;

If not, let the first thread acquire the lock;

If yes, when the target thread data of the lock thread meets the preset condition, the first thread is allowed to acquire the lock;

When receiving the unlock request of the first thread, determine whether the first data exists in the shared cache;

If it does not exist, change the first data of the first thread to unlock the first thread;

If it exists, change the first data in the shared cache to unlock the first thread.
The method of claim 12, further comprising:

When receiving the lock request of the second thread, determine whether the lock is occupied according to the data of the lock corresponding to the second data of the second thread, and write the second data to the lock in the shared cache. Cache line;

If not, let the second thread acquire the lock;

If so, when the first data meets a preset condition, the second thread is made to acquire the lock.
The method according to claim 13, further comprising:

When receiving the unlock request of the second thread, determine whether the second data exists in the cache line;

If it does not exist, change the second data of the second thread to unlock the second thread.

and / or,

When receiving the unlock request of the second thread, determine whether the second data exists in the cache line;

If it exists, change the second data in the shared cache to unlock the second thread.
The method according to claim 13, if the receiving of the lock request of the second thread is earlier than the receiving of the unlock request of the first thread, the data corresponding to the second data of the lock is the first One data;

and / or,

If receiving the lock request of the second thread is later than receiving the unlock request of the first thread, the data corresponding to the second data of the lock is the first data in the shared cache. The changed data.
The method according to any one of claims 12 to 15, wherein determining whether the lock is occupied according to the data corresponding to the first data of the first thread of the lock comprises:

If the data corresponding to the first data of the first thread of the lock is empty, the lock is not occupied;

If the data corresponding to the first data of the first thread of the lock is not empty, the lock is occupied.
According to the method of any one of claims 12 to 15, for any data, if the data is greater than the corresponding lock data, the data meets the preset condition.
The method according to any one of claims 12 to 15, wherein the target thread data belongs to data used by the lock-holding thread to write to the shared cache.
The method according to any one of claims 12 to 15, wherein the shared cache is the last level cache.
The method according to any one of claims 12 to 15, wherein the first data includes a private data address and private data of the first thread.
15. The method according to any one of claims 12 to 15, wherein the first data is a pending value of the first thread.
21. The method of claim 21, modifying the first data of the first thread comprises:

Add 1 to the pending value of the first thread.
15. The method according to any one of claims 13 to 15, wherein the second data is a pending value of the second thread.
The method of claim 23, wherein modifying the second data of the second thread comprises:

Add 1 to the pending value of the second thread.
The method according to any one of claims 12 to 15, wherein modifying the first data in the shared cache includes:

Write the first data in the cache line as empty.
The method of claim 14, wherein modifying the second data in the shared cache comprises:

Write the second data in the cache line as empty.
A data processing device includes:

The locking module is configured to interact with the lock data and thread data of the thread to be locked through the shared cache of the processor when receiving the lock request of the thread to be locked, and determine whether the lock is occupied according to the lock data; and If the lock is not occupied, the thread to be locked is allowed to obtain the lock; if the lock is occupied, when the target thread data of the lock-occupiing thread meets the preset condition, the thread to be locked is allowed to obtain the lock;

and / or,

The unlocking module is used to determine whether the thread data written into the shared cache is used for data interaction with the lock through the processor's shared cache before the lock-occupying thread is receiving the unlocking request of the lock-occupiing thread Change; and, if the thread data written to the shared cache is changed during the interaction, change the thread data of the lock-occupying thread to unlock the lock-occupying thread.
A data processing device includes:

The locking module is used to determine whether the lock is occupied according to the data corresponding to the first data of the first thread when receiving the lock request of the first thread, and write the first data to the processor The cache line of the lock in the shared cache; and, if the lock is not occupied, the first thread is allowed to obtain the lock; if the lock is occupied, when the target thread data of the lock-occupying thread meets the preset condition, the Acquiring the lock by the first thread;

The unlocking module is configured to determine whether the first data exists in the shared cache when receiving the unlock request of the first thread; and, if the first data does not exist, change the first data. The first data of the thread unlocks the first thread; and, if the first data exists, the first data in the shared cache is changed to unlock the first thread.
A data processing device, including:

At least one processor; and,

A memory connected in communication with the at least one processor;

Wherein, the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can:

When receiving the lock request of the thread to be locked, perform the interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor, and determine whether the lock is occupied according to the lock data;

If not, enable the thread to be locked to obtain the lock;

If so, when the target thread data of the lock thread meets the preset condition, the thread to be locked is allowed to obtain the lock; and/or,

When receiving the unlock request of the lock-occupiing thread, determine whether the thread data written in the shared cache is changed when the thread-occupying thread performs data interaction with the lock through the shared cache of the processor before the lock-occupiing thread seizes the lock;

If it is changed, the thread data of the lock occupying thread is changed to unlock the lock occupying thread.
A data processing device, including:

At least one processor; and,

A memory connected in communication with the at least one processor;

Wherein, the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can:

When receiving the lock acquisition request of the first thread, determine whether the lock is occupied according to the data corresponding to the first data of the first thread, and write the first data into the shared cache of the processor. Locked cache line;

If not, let the first thread acquire the lock;

If yes, when the target thread data of the lock thread meets the preset condition, the first thread is allowed to acquire the lock;

When receiving the unlock request of the first thread, determine whether the first data exists in the shared cache;

If it does not exist, change the first data of the first thread to unlock the first thread;

If it exists, change the first data in the shared cache to unlock the first thread.
A computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the following steps are implemented:

When receiving the lock request of the thread to be locked, perform the interaction between the lock data and the thread data of the thread to be locked through the shared cache of the processor, and determine whether the lock is occupied according to the lock data;

If not, enable the thread to be locked to obtain the lock;

If so, when the target thread data of the lock thread meets the preset condition, the thread to be locked is allowed to obtain the lock; and/or,

When receiving the unlock request of the lock-occupiing thread, determine whether the thread data written in the shared cache is changed when the thread-occupying thread performs data interaction with the lock through the shared cache of the processor before the lock-occupiing thread seizes the lock;

If it is changed, the thread data of the lock occupying thread is changed to unlock the lock occupying thread.
A computer-readable storage medium that stores computer-executable instructions. When the computer-executable instructions are executed by a processor, the following steps are implemented:

When receiving the lock acquisition request of the first thread, determine whether the lock is occupied according to the data corresponding to the first data of the first thread, and write the first data into the shared cache of the processor. Locked cache line;

If not, let the first thread acquire the lock;

If yes, when the target thread data of the lock thread meets the preset condition, the first thread is allowed to acquire the lock;

When receiving the unlock request of the first thread, determine whether the first data exists in the shared cache;

If it does not exist, change the first data of the first thread to unlock the first thread;

If it exists, change the first data in the shared cache to unlock the first thread.