WO2021057643A1

WO2021057643A1 - Multi-thread synchronization method and electronic device

Info

Publication number: WO2021057643A1
Application number: PCT/CN2020/116437
Authority: WO
Inventors: 杨启彬; 黄施昱
Original assignee: 华为技术有限公司
Priority date: 2019-09-25
Filing date: 2020-09-21
Publication date: 2021-04-01
Also published as: CN111552574A; EP4020210A4; EP4020210A1; US20220350602A1

Abstract

A multi-thread synchronization method and an electronic device, wherein same relate to the technical field of terminals. The method comprises: a first thread requesting the acquisition of a target lock. Specifically, a first thread requesting the acquisition of a target lock involves the following steps: the first thread acquiring a lock state variable of the target lock, wherein the lock state variable comprises a lock holding thread identification field and a blocked thread number field; the first thread then checking the lock holding thread identification field; if it is checked and found that the lock holding thread identification field is a valid thread and is not the first thread, the first thread checking the blocked thread number field; if it is checked and found that the blocked thread number field is less than a first threshold value, the first thread performing spin waiting; and when the number of times of spin waiting reaches a second threshold value, if it is checked and found that the lock holding thread identification field is a valid thread and is not the first thread, the first thread adding one to the blocked thread number field, and being suspended from entering a blocked state. The technical solution is conducive to reducing the duration needed for a lock holding thread to access a shared resource, thereby reducing the probability of lagging of an electronic device.

Description

Multithread synchronization method and electronic equipment

Cross-references to related applications

This application claims the priority of a Chinese patent application filed with the Chinese Patent Office on September 25, 2019, the application number is 201910912971.6, and the application name is "a multi-threaded access method and electronic equipment", the entire content of which is incorporated herein by reference In application; this application requires the priority of a Chinese patent application filed with the Chinese Patent Office, the application number is 202010245880.4, and the application name is "a multi-thread synchronization method and electronic equipment" on March 31, 2020, the entire content of which is incorporated by reference Incorporated in this application.

Technical field

This application relates to the field of terminal technology, and in particular to a multi-thread synchronization method and electronic equipment.

Background technique

The Android operating system is usually used in electronic devices such as mobile phones and tablet computers to provide a unified interface and a friendly interactive interface for users to use electronic devices, and can support multi-threaded operation. At present, in the Android operating system, shared resources (such as shared memory, shared code, shared data, etc.) can be accessed by multiple threads. In order to prevent multiple threads from simultaneously accessing shared resources, the shared resources are protected by locks. Take lock 1 to protect shared resource 1 as an example. In multithreading, only the thread holding lock 1 can access shared resource 1. Once a thread acquires lock 1, other threads can no longer hold lock 1, that is, lock 1 can only be held by one thread at the same time. Have. Only when the thread holding lock 1 releases lock 1, other threads get the opportunity to hold lock 1.

However, in the prior art, threads usually use a lock expansion strategy to compete for locks. Although this method realizes that a lock can only be held by one thread at the same time, it easily leads to an increase in the length of time that the lock-holding thread accesses shared resources, and the probability of electronic device jamming increases, which reduces user experience.

Summary of the invention

The embodiments of the present application provide a multi-thread synchronization method and an electronic device, which help reduce the length of time that a lock-holding thread accesses a shared resource, thereby reducing the probability of the electronic device being stuck and improving the user experience.

The first aspect is a multi-thread synchronization method according to an embodiment of this application, which specifically includes: a first thread requests to acquire a target lock.

Among them, the first thread requests to acquire the target lock, including:

Step 1. The first thread acquires the lock state variable of the target lock. The lock state variable includes the lock-holding thread identification field and the blocked thread number field. The lock-holding thread identification field is used to indicate the lock-holding thread of the target lock, and the blocked thread number field is used To indicate the number of threads that are blocked for the target lock;

Step 2: The first thread checks the lock thread identification field;

Step 3: If the first thread checks that the lock-holding thread identification field is a valid thread and is not the first thread, the first thread checks the blocked thread number field;

Step 4: If the first thread checks that the number of blocked threads is less than the first threshold, the first thread performs spin waiting;

Step 5. When the number of spin waits for the first thread reaches the second threshold, if the check that the lock-holding thread identification field is a valid thread and not the first thread, the first thread performs an operation of incrementing the number field of blocked threads and hangs. Start to enter the blocking state.

In the embodiment of the present application, since the lock state variable of the target lock includes the lock thread identification field and the blocked thread number field, and the blocked thread number field is used to indicate the number of threads in the blocked state for the target lock, the lock-holding thread will not be blocked. The thread field is modified so that when the number of spin waits for the first thread reaches the second threshold, if the lock-holding thread identification field is checked as a valid thread other than the first thread, the first thread does not need to suspend the lock-holding thread , Without allocating montior objects, it is possible to add 1 to the blocked thread number field, which helps to reduce the length of time that the lock-holding thread accesses shared resources, thereby reducing the probability of electronic device jams and improving user experience.

In a possible design, after step three, it also includes:

Step 6. If the first thread checks that the blocked thread number field is greater than or equal to the first threshold, the first thread performs an operation of adding 1 to the blocked thread number field and suspends and enters the blocking state.

In a possible design, the lock state variable also includes a repeated lock count field, and the repeated lock count field is used to indicate the number of locks held by the lock thread for the target lock. As a result, the lock state variable can record the number of locks held by the lock-holding thread for the target lock, which helps reduce the possibility of exceptions when the lock-holding thread releases the lock.

In a possible design, after step two, it also includes:

Step 7. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread performs an operation of adding 1 to the repeated lock-holding times field. Since the repeated lock count field is used to indicate the number of locks held by the lock thread for the target lock, and the first thread adds 1 to the repeated lock count field, there is no need to allocate a monitor object, which helps to improve the running performance of the first thread. Efficiency, further reducing the probability of electronic equipment jams, thereby improving user experience.

In a possible design, after step two, it also includes:

Step 8. If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread, and sets the number of repeated locks field to the initial value.

In a possible design, the method further includes: the first thread requests to release the target lock.

Among them, the first thread requests to release the target lock, including:

Step 9. The first thread acquires the lock state variable of the target lock:

Step 10. The first thread checks the lock thread identification field;

Step 11. If the first thread checks the lock-holding thread identification field as the first thread, the first thread checks the repeated lock-holding times field;

Step 12: If the first thread checks that the repeated lock count field is not 0, the first thread performs an operation to subtract 1 from the repeated lock count field.

Through the above technical solution, it is helpful to simplify the process of the first thread requesting to release the target lock.

In a possible design, after step twelve, it also includes:

Step 13. If the first thread checks that the repeated lock count field is 0, the first thread sets the lock thread identification field as an invalid thread;

Step 14. The first thread checks the blocked thread count field;

Step 15. If the first thread checks that the blocked thread count field is not 0, the first thread wakes up at least one thread that is blocked for the target lock.

After the first thread releases control of the target lock, it can also wake up at least one thread that is blocked for the target lock, thereby increasing the possibility that the thread locks the target and improving the efficiency of thread operation.

In a possible design, the method further includes: the first thread requests to suspend the lock on the target.

Among them, the first thread's request to suspend the lock on the target includes:

Step 16. The first thread acquires the lock state variable of the target lock;

Step 17. The first thread checks the lock thread identification field;

Step 18. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread saves the repeated lock-holding times field as the context of the first thread for the target lock;

Step 19. The first thread adds the thread identification ID of the first thread to the thread waiting list corresponding to the ID of the target lock;

Step 20: The first thread sets the number of repeated locks field to 0, and sets the lock thread identification field to be an invalid thread, and suspends and enters a blocking state.

In the embodiment of the present application, since the first thread can add the thread ID of the first thread to the thread waiting list corresponding to the ID of the target lock, it is convenient for the first thread to be awakened by other threads or systems.

In a possible design, after step 20, it also includes:

Step 21: After the first thread is awakened, acquire the lock state variable of the target lock;

Step 22: The first thread checks the lock thread identification field;

Step 23: If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread, and sets the number of repeated locks according to the context of the first thread for the target lock area;

Step 24: The first thread deletes the thread ID of the first thread in the thread waiting list corresponding to the ID of the target lock.

Through the above technical solution, if the first thread requests to suspend the lock on the target, if it is awakened again, the lock on the target can be resumed.

In a possible design, the first thread can be awakened in the following manner to acquire the lock state variable of the target lock:

After the first thread is awakened by the second thread, it acquires the lock state variable of the target lock. The second thread wakes up the second thread when the thread ID of the first thread is stored in the thread waiting list corresponding to the ID of the target lock. Threaded; the second thread belongs to the same process as the first thread; or,

The first thread is awakened by the system when the suspended duration exceeds the third threshold, and acquires the lock state variable of the target lock.

This helps to simplify the way in which the first thread is awakened when the first thread requests to suspend the lock on the target.

In a possible design, the blocked thread number field includes a first value and a high-order flag of the number of blocked threads. The first value is the low-order value of the number of threads in a blocked state for the target lock, and the high-order flag of the number of blocked threads is used to indicate Whether the second value corresponding to the ID of the target lock is stored in the high list of the number of blocked threads, and the second value is the high value of the number of threads in the blocked state for the target lock. This helps to avoid overflow when the number of threads that are blocked for the target lock is large.

In a possible design, the field of the number of repeated locks includes a third value and a high flag of the number of repeated locks. The third value is the low value of the number of locks held by the lock thread for the target lock, and the number of repeated locks is high. The identifier is used to indicate whether the high-order list of the number of repeated locks stores a fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread. The fourth value is the high-order value of the number of times the lock-holding thread holds the lock for the target lock. value. This helps to avoid overflow when the lock-holding thread holds more locks for the target lock.

In a possible design, the first thread can suspend and enter the blocking state based on the following methods:

The first thread makes a system call, sets the state of the first thread to a sleep state, and adds the first thread to the waiting queue corresponding to the address of the target lock. This helps simplify the implementation.

The second aspect is an electronic device according to an embodiment of this application, which specifically includes a processor and a memory, where program instructions are stored; the processor calls the program instructions stored in the memory for the first thread to request to acquire the target lock;

Among them, the first thread requests to acquire the target lock, including:

Step 2: The first thread checks the lock thread identification field:

In a possible design, after step three, it also includes:

In a possible design, the lock state variable of the target lock also includes a repeated lock count field, and the repeated lock count field is used to indicate the number of locks held by the lock thread for the target lock.

In a possible design, after step two, it also includes:

Step 7. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread performs an operation of adding 1 to the repeated lock-holding times field.

In a possible design, after step two, it also includes:

In a possible design, the processor calls the program instructions, which are also used by the first thread to request the release of the target lock:

Among them, the first thread requests to release the target lock, including:

Step 9. The first thread acquires the lock state variable of the target lock:

Step 10. The first thread checks the lock thread identification field;

In a possible design, after step twelve, it also includes:

Step 14. The first thread checks the blocked thread count field;

In a possible design, the processor calls the program instructions, which are also used by the first thread to request the suspension of the lock on the target:

Step 16. The first thread acquires the lock state variable of the target lock;

Step 17. The first thread checks the lock thread identification field;

Step 18. If the first thread checks that the lock-holding thread identification field is the first thread, save the repeated lock-holding times field as the context of the first thread for the target lock;

In a possible design, after step 20, it also includes:

Step 22: The first thread checks the lock thread identification field;

In a possible design, the first thread can be awakened based on the following methods, and then acquire the lock state variable of the target lock:

When the first thread is awakened by the second thread, it acquires the lock state variable of the target lock. The second thread wakes up the second thread when the thread ID of the first thread is stored in the thread waiting list corresponding to the ID of the target lock. Threaded; the second thread belongs to the same process as the first thread; or,

In a possible design, the blocked thread number field includes a first value and a high-order flag of the number of blocked threads. The first value is the low-order value of the number of threads in a blocked state for the target lock, and the high-order flag of the number of blocked threads is used to indicate Whether the second value corresponding to the ID of the target lock is stored in the high list of the number of blocked threads, and the second value is the high value of the number of threads in the blocked state for the target lock.

In a possible design, the field of the number of repeated locks includes a third value and a high flag for the number of repeated locks. The third value is the low value of the number of locks held by the lock thread for the target lock, and the number of repeated locks is high. The identifier is used to indicate whether the high-order list of the number of repeated locks stores the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread. The fourth value is the high-order number of the lock-holding thread for the target lock. value.

The first thread makes a system call, sets the state of the first thread to a sleep state, and adds the first thread to the waiting queue corresponding to the address of the target lock.

In a third aspect, an electronic device provided by an embodiment of the present application includes a device for executing the foregoing first aspect and any possible design method involved in the first aspect of the embodiment of the present application.

In a fourth aspect, a chip provided by an embodiment of the present application includes a processor and an interface, configured to call and run the program instructions stored in the memory from the memory, and execute the above-mentioned first aspect and the first aspect of the embodiment of the present application. Any possible design method involved in the aspect.

In a fifth aspect, a computer-readable storage medium according to an embodiment of the present application. The computer-readable storage medium stores program instructions. When the program instructions run on an electronic device, the electronic device executes the above-mentioned On the one hand and any possible design method involved in the first aspect.

In a sixth aspect, a computer program product of an embodiment of the present application, when the computer program product runs on an electronic device, causes the electronic device to execute and implement the above-mentioned first aspect and any of the first aspects of the embodiments of the present application. A possible design method.

In addition, the technical effects brought by any of the possible design methods of the second aspect to the sixth aspect can be referred to the technical effects brought about by the different design methods in the related method section, which will not be repeated here.

Description of the drawings

FIG. 1 is a schematic diagram of the format of a lock state variable according to an embodiment of the application;

2 is a schematic diagram of the hardware structure of an electronic device according to an embodiment of the application;

FIG. 3 is a schematic diagram of the software structure of an electronic device according to an embodiment of the application;

FIG. 4 is a schematic diagram of a storage format of the high-order value of the number of blocked threads according to an embodiment of the application;

FIG. 5 is a schematic diagram of a storage format of the high-order value of the number of repeated locks according to an embodiment of the application; FIG.

FIG. 6 is a schematic diagram of the format of another lock state variable according to an embodiment of the application;

FIG. 7 is a schematic diagram of a storage format of a hash value according to an embodiment of the application;

FIG. 8 is a schematic flowchart of a multi-thread synchronization method according to an embodiment of the application;

FIG. 9 is a schematic flowchart of a process of adding 1 to the number field of blocked threads according to an embodiment of the present application;

FIG. 10 is a schematic diagram of a flow chart of performing an operation of adding 1 to the repeated lock count field according to an embodiment of the present application; FIG.

FIG. 11 is a schematic flowchart of another multi-thread synchronization method according to an embodiment of the application;

FIG. 12 is a schematic diagram of a flow chart of performing a minus 1 operation on the repeated lock count field according to an embodiment of the application; FIG.

FIG. 13 is a schematic flowchart of another multi-thread synchronization method according to an embodiment of the application;

FIG. 14 is a schematic diagram of a storage format of a thread waiting list according to an embodiment of the application;

15 is a schematic diagram of a process of deleting a thread ID from a thread waiting list according to an embodiment of the application;

16 is a schematic flowchart of another multi-thread synchronization method according to an embodiment of the application;

FIG. 17 is a schematic flowchart of another multi-thread synchronization method according to an embodiment of the application;

18 is a schematic diagram of another format of a lock state variable according to an embodiment of the application;

FIG. 19 is a schematic structural diagram of another electronic device according to an embodiment of the application.

detailed description

It should be understood that “at least one” in the embodiments of the present application refers to one or more. "Multiple" means two or more. "And/or" describes the association relationship of the associated objects, indicating that there can be three types of relationships. For example, A and/or B can mean that: A alone exists, A and B exist at the same time, and B exists alone. Among them, A and B can be singular or plural. The character "/" generally indicates that the associated objects before and after are in an "or" relationship. "The following at least one (item)" or similar expressions refers to any combination of these items, including any combination of single item (item) or plural items (item). For example, at least one item (a) of a, b, or c can represent: a, b, c, a and b, a and c, b and c, or a, b and c. Among them, each of a, b, and c can be an element itself, or a collection containing one or more elements.

In this application, "exemplary", "in some embodiments", "in other embodiments", etc. are used to represent examples, illustrations, or illustrations. Any embodiment or design solution described as an "example" in this application should not be construed as being more preferable or advantageous than other embodiments or design solutions. To be precise, the term example is used to present the concept in a concrete way.

It should be pointed out that the terms "first" and "second" involved in the embodiments of this application are only used for the purpose of distinguishing description, and cannot be understood as indicating or implying relative importance, nor shall they be understood as indicating or implying. order.

The electronic device executes the corresponding program through the operating system (for example, the Android operating system), so that the user can use the electronic device to make calls, send short messages, browse the web, take photos, play games, watch videos, and so on. Generally, a thread is the smallest unit of program execution. At present, the operating system of an electronic device can support multi-threaded operation, thereby realizing parallel processing of multi-tasks and improving task processing efficiency. However, in the Android operating system, shared resources (for example, shared code, shared memory, shared data or variables, etc.) can be accessed by multiple threads. In order to prevent multiple threads from accessing resources at the same time, shared resources are protected by locks. Take lock 1 to protect shared resource 1 as an example. In multithreading, only the thread holding lock 1 can access shared resource 1. Once lock 1 is held by a thread, other threads can no longer hold lock 1 and only after the lock holding thread releases lock 1 , Other threads get the opportunity to hold lock 1.

In the prior art, threads use a lock expansion strategy to compete for locks. Specifically, the thread realizes the competition to hold the lock according to the lock state variable (lockword). In other words, the thread judges whether it can hold the lock 1 according to the lock state variable.

For example, in the Android operating system, the format of the lockword is shown in FIG. 1, and includes a status bit, a reserved bit (reserve), a field for the number of repeated locks, and a lock thread identification field. The status bit is used to indicate the lock status. The information indicated by the repeated lock count field and the lock thread identification field of the lockword is related to the lock state. For example, when the status bit is set to 01, it indicates the relock state, and when the status bit is set to 01, the repeated lock count field and the lock thread identification field are used to indicate the monitor object; when the status bit is 00, the light lock state is used. In the case that the status bit is set to 00, the number of repeated locks field is used to indicate the number of locks held by the lock-holding thread for the lock, and the lock-holding thread identification field is used to indicate the lock-holding thread of the lock.

Take thread 1 requesting lock 1 as an example. Thread 1 requests to acquire lock 1, which specifically includes the following steps:

First, thread 1 acquires the lockword.

Second, thread 1 checks the lock-holding thread ID field.

One situation: If thread 1 checks the lock-holding thread identification field to be a thread other than thread 1, thread 1 continues to check the status bit.

If the thread 1 checks the status bit for the relocked state, the thread 1 suspends and enters the blocking state.

If the thread 1 checks the status bit for the light lock state, it performs spin waiting. When the spin waiting reaches a certain threshold, if the check-holding thread identification field is still a thread other than thread 1, thread 1 suspends the lock-holding thread of lock 1, allocates a monitor object, and sets the status bit to relock State, and then wake up the lock holding thread of lock 1, and then thread 1 suspends and enters the blocking state.

Another case: if thread 1 checks the lock thread identification field to be thread 1, thread 1 performs an operation to add 1 to the repeated lock count field. If the check repeated lock count domain reaches a certain threshold, thread 1 allocates a monitor object and sets the status bit to the relock state.

In another case, if thread 1 checks the lock thread identification field as an invalid thread, that is, no thread holds a lock on lock 1, thread 1 sets the lock state identification field as the first thread and initializes the repeated lock count field.

As can be seen from the above content, based on the lock state variable shown in Figure 1, when a thread requests to acquire a lock or request to hold a lock, since both the lock-holding thread and the non-lock-holding thread can operate on the status bit, the status bit is In the light lock state, if the non-locking thread needs to modify the status bit, in order to avoid that the lock-holding thread also modifies the status bit, the non-locking thread needs to suspend the lock-holding thread and wake up after the status bit is modified. Lock thread. In addition, whether it is a lock-holding thread or a non-lock-holding thread, to modify the status bit from the light-locked state to the heavy-locked state, a monitor object needs to be allocated. Therefore, the thread judges whether the lock can be held based on the existing lockword. It is easy to increase the length of time that the lock-holding thread accesses the shared resource, resulting in an increase in the response delay of the application in which the lock-holding thread is located in the electronic device, thereby increasing the probability of the electronic device being stuck and reducing the user experience.

In view of this, the embodiment of the present application provides a multi-thread synchronization method. The lock state variable (lockword) is redefined, so that the lock state variable includes the lock thread identification field, the repeated lock count field, and the blocked thread number field. , Where the lock thread identification field is used to indicate the lock thread of the target lock, the repeated lock count field is used to indicate the number of locks held by the lock thread for the target lock, and the blocked thread number field is used to indicate that the target lock is in The number of threads in the blocked state, because the lock-holding thread identification field and the repeated lock-holding times field are only set by the lock-holding thread, and the blocked thread number field is only set by the non-locking thread. Therefore, the non-locking thread's spin waiting reaches a certain value. When the threshold is set, if the lock-holding thread identification field is checked for other threads, the non-lock-holding thread performs an increment operation on the blocked thread number field and suspends into the blocking state. Compared with the prior art, there is no need to hang the lock-holding thread first. As a result, there is no need to allocate monitor objects, and perform an operation of adding 1 to the blocked thread number field, thus reducing the time length of the lock-holding thread accessing shared resources, reducing the probability of electronic device jams, and helping to improve user experience.

For example, the electronic devices in the embodiments of the present application may be mobile phones, tablet computers, wearable devices, in-vehicle devices, augmented reality (AR)/virtual reality (VR) devices, notebook computers, super mobile personal computers (ultra-mobile personal computer, UMPC), netbook, personal digital assistant (personal digital assistant, PDA), etc. The embodiments of this application do not impose any restrictions on the specific types of electronic devices.

As an example, as shown in FIG. 2, it is a schematic structural diagram of an electronic device according to an embodiment of the application. Specifically, as shown in the figure, the electronic device includes a processor 110, an external memory interface 120, an internal memory 121, a universal serial bus (USB) interface 130, a charging management module 140, a power management module 141, and a battery 142 , Antenna 1, antenna 2, mobile communication module 150, wireless communication module 160, audio module 170, speaker 170A, receiver 170B, microphone 170C, earphone interface 170D, sensor module 180, buttons 190, motor 191, indicator 192, camera 193 , A display screen 194, and a subscriber identification module (SIM) card interface 195, etc. The sensor module 180 may include a pressure sensor, a gyroscope sensor, an air pressure sensor, a magnetic sensor, an acceleration sensor, a distance sensor, a proximity light sensor, a fingerprint sensor, a temperature sensor, a touch sensor, an ambient light sensor, a bone conduction sensor, etc.

The processor 110 may include one or more processing units. For example, the processor 110 may include an application processor (AP), a modem (modem), a graphics processing unit (GPU), an image signal processor (ISP), a controller, and a video editor. Decoder, digital signal processor (digital signal processor, DSP), baseband processor, and/or neural network processor (neural-network processing unit, NPU), etc. Among them, the different processing units may be independent devices, or two or more different processing units may also be integrated into one device.

The controller can be the nerve center and command center of the electronic device. The controller can generate operation control signals according to the instruction operation code and timing signals to complete the control of fetching and executing instructions.

A memory may also be provided in the processor 110 to store instructions and data. In some embodiments, the memory in the processor 110 is a cache memory. The memory can store instructions or data that the processor 110 has just used or used cyclically. If the processor 110 needs to use the instruction or data again, it can be directly called from the memory. Repeated accesses are avoided, the waiting time of the processor 110 is reduced, and the efficiency of the system is improved.

In some embodiments, the processor 110 may include one or more interfaces. For example, the processor 110 includes a universal serial bus (USB) interface 130 and a subscriber identity module (SIM) interface 195. For another example, the processor 110 may also include an integrated circuit (I2C) interface, an integrated circuit audio (inter-integrated circuit sound, I2S) interface, a pulse code modulation (PCM) interface, and a universal asynchronous A universal asynchronous receiver/transmitter (UART) interface, a mobile industry processor interface (MIPI), and/or a general-purpose input/output (GPIO) interface, etc.

It can be understood that the interface connection relationship between the modules illustrated in the embodiment of the present application is merely a schematic description, and does not constitute a structural limitation of the electronic device. In other embodiments of the present application, the electronic device may also adopt different interface connection modes in the foregoing embodiments, or a combination of multiple interface connection modes.

The USB interface 130 is an interface that complies with the USB standard specification, and specifically may be a Mini USB interface, a Micro USB interface, a USB Type C interface, and the like. The USB interface 130 can be used to connect a charger to charge the electronic device, and can also be used to transfer data between the electronic device and the peripheral device. It can also be used to connect headphones and play audio through the headphones. This interface can also be used to connect to other electronic devices, such as AR devices.

The SIM card interface 195 is used to connect to the SIM card. The SIM card can be inserted into the SIM card interface 195 or pulled out from the SIM card interface 195 to achieve contact and separation with the electronic device. The electronic device can support 1 or N SIM card interfaces, and N is a positive integer greater than 1. The SIM card interface 195 can support Nano SIM cards, Micro SIM cards, SIM cards, etc. The same SIM card interface 195 can insert multiple cards at the same time. The types of the multiple cards can be the same or different. The SIM card interface 195 can also be compatible with different types of SIM cards. The SIM card interface 195 may also be compatible with external memory cards. The electronic device interacts with the network through the SIM card to realize functions such as call and data communication. In some embodiments, the electronic device adopts an eSIM, that is, an embedded SIM card. The eSIM card can be embedded in the electronic device and cannot be separated from the electronic device.

The charging management module 140 is used to receive charging input from the charger. Among them, the charger can be a wireless charger or a wired charger. In some wired charging embodiments, the charging management module 140 may receive the charging input of the wired charger through the USB interface 130. In some embodiments of wireless charging, the charging management module 140 may receive the wireless charging input through the wireless charging coil of the electronic device. While the charging management module 140 charges the battery 142, it can also supply power to the electronic device through the power management module 141.

The power management module 141 is used to connect the battery 142, the charging management module 140, and the processor 110. The power management module 141 receives input from the battery 142 and/or the charging management module 140, and supplies power to the processor 110, the internal memory 121, the external memory, the display screen 194, the camera 193, and the wireless communication module 160. The power management module 141 can also be used to monitor parameters such as battery capacity, battery cycle times, and battery health status (leakage, impedance). In some other embodiments, the power management module 141 may also be provided in the processor 110. In other embodiments, the power management module 141 and the charging management module 140 may also be provided in the same device.

The wireless communication function of the electronic device can be realized by the antenna 1, the antenna 2, the mobile communication module 150, the wireless communication module 160, the modem, and the baseband processor.

The antenna 1 and the antenna 2 are used to transmit and receive electromagnetic wave signals. Each antenna in an electronic device can be used to cover a single or multiple communication frequency bands. Different antennas can also be reused to improve antenna utilization. For example: Antenna 1 can be multiplexed as a diversity antenna of a wireless local area network. In other embodiments, the antenna can be used in combination with a tuning switch.

The mobile communication module 150 can provide a wireless communication solution including 2G/3G/4G/5G and other standards applied to electronic devices. The mobile communication module 150 may include at least one filter, a switch, a power amplifier, a low noise amplifier (LNA), and the like.

The wireless communication module 160 includes wireless local area networks (WLAN) (such as Wi-Fi networks), Bluetooth (BT), and global navigation satellite system (GNSS) that can be applied to electronic devices. ), frequency modulation (FM), near field communication (NFC), infrared technology (infrared, IR) and other wireless communication solutions.

In some embodiments, the antenna 1 of the electronic device is coupled with the mobile communication module 150, and the antenna 2 is coupled with the wireless communication module 160, so that the electronic device can communicate with the network and other devices through wireless communication technology. The wireless communication technology may include global system for mobile communications (GSM), general packet radio service (GPRS), code division multiple access (CDMA), broadband Code division multiple access (wideband code division multiple access, WCDMA), time-division code division multiple access (TD-SCDMA), long term evolution (LTE), BT, GNSS, WLAN, NFC , FM and/or IR technology, etc. The GNSS may include global positioning system (GPS), global navigation satellite system (GLONASS), Beidou navigation satellite system (BDS), and quasi-zenith satellite system (quasi). -zenith satellite system, QZSS) and/or satellite-based augmentation systems (SBAS).

The electronic device realizes the display function through the GPU, the display screen 194, and the application processor. The display screen 194 is used to display images, videos, and the like. The display screen 194 includes a display panel. The display panel can adopt liquid crystal display (LCD), organic light-emitting diode (OLED), active matrix organic light-emitting diode or active-matrix organic light-emitting diode (active-matrix organic light-emitting diode). AMOLED), flexible light-emitting diode (FLED), Miniled, MicroLed, Micro-oLed, quantum dot light-emitting diode (QLED), etc. In some embodiments, the electronic device may include one or N display screens 194, and N is a positive integer greater than one.

The electronic device can realize the shooting function through ISP, camera 193, video codec, GPU, display screen 194 and application processor. The ISP is used to process the data fed back by the camera 193. For example, when taking a picture, the shutter is opened, the light is transmitted to the photosensitive element of the camera through the lens, the light signal is converted into an electrical signal, and the photosensitive element of the camera transmits the electrical signal to the ISP for processing and is converted into an image visible to the naked eye. ISP can also optimize the image noise, brightness, and skin color. ISP can also optimize the exposure, color temperature and other parameters of the shooting scene. In some embodiments, the ISP may be provided in the camera 193.

The camera 193 is used to capture still images or videos. The object generates an optical image through the lens and is projected to the photosensitive element. The photosensitive element may be a charge coupled device (CCD) or a complementary metal-oxide-semiconductor (CMOS) phototransistor. The photosensitive element converts the optical signal into an electrical signal, and then transfers the electrical signal to the ISP to convert it into a digital image signal. ISP outputs digital image signals to DSP for processing. DSP converts digital image signals into standard RGB, YUV and other formats of image signals. In some embodiments, the electronic device may include 1 or N cameras 193, and N is a positive integer greater than 1.

The external memory interface 120 may be used to connect an external memory card, such as a Micro SD card, to expand the storage capacity of the electronic device. The external memory card communicates with the processor 110 through the external memory interface 120 to realize the data storage function. For example, save music, video and other files in an external memory card.

The internal memory 121 includes a running memory (memory) and a built-in memory. Among them, the running memory can be used to store computer executable program code or data. The executable program code includes instructions. The processor 110 executes various functional applications and data processing of the electronic device by running instructions stored in the running memory. For example, the running memory may include high-speed random access memory. The built-in memory can also be called a built-in external memory, etc., which can be used to store programs and/or data. For example, the built-in memory can store an operating system, application programs, and so on. The electronic device usually loads the program and/or data in the built-in memory into the running memory, so that the processor 110 runs the corresponding program and/or data to realize the corresponding function. In addition, the internal memory 121 may include a non-volatile memory, such as at least one magnetic disk storage device, a flash memory device, a universal flash storage (UFS), and the like.

The electronic device can implement audio functions through the audio module 170, the speaker 170A, the receiver 170B, the microphone 170C, the earphone interface 170D, and the application processor. For example, music playback, recording, etc.

The button 190 includes a power button, a volume button, and so on. The button 190 may be a mechanical button. It can also be a touch button. The electronic device can receive key input, and generate key signal input related to user settings and function control of the electronic device.

The motor 191 can generate vibration prompts. The motor 191 can be used for incoming call vibration notification, and can also be used for touch vibration feedback. For example, touch operations that act on different applications (such as photographing, audio playback, etc.) can correspond to different vibration feedback effects. Acting on touch operations in different areas of the display screen 194, the motor 191 can also correspond to different vibration feedback effects. Different application scenarios (for example: time reminding, receiving information, alarm clock, games, etc.) can also correspond to different vibration feedback effects. The touch vibration feedback effect can also support customization.

The indicator 192 may be an indicator light, which may be used to indicate the charging status, power change, or to indicate messages, missed calls, notifications, and the like.

It can be understood that the structure illustrated in the embodiments of the present application does not constitute a specific limitation on the electronic device. In other embodiments of the present application, the electronic device may include more or fewer components than those shown in the figure, or combine certain components, or split certain components, or arrange different components. The illustrated components can be implemented in hardware, software, or a combination of software and hardware.

The software system of the electronic device in the embodiment of the present application may also be referred to as an operating system, which supports multi-threaded operation, and may adopt a layered architecture, an event-driven architecture, a micro-core architecture, a micro-service architecture, or a cloud architecture. Among them, the layered architecture (for example, the Android operating system) divides the software into several layers, each layer has a clear role and division of labor, and communication between layers is through software interfaces.

Specifically, FIG. 3 shows a structural block diagram of a software system of an electronic device according to an embodiment of the present application. The layered architecture divides the software into several layers, and each layer has a clear role and division of labor. Communication between layers through software interface. In some embodiments, the Android system is divided into four layers, from top to bottom, the application layer, the application framework layer, the Android runtime and system library, and the kernel layer. The application layer can include a series of application packages.

As shown in Figure 3, the application package may include applications such as camera, gallery, calendar, call, map, navigation, WLAN, Bluetooth, music, video, short message, etc.

The application framework layer provides an application programming interface (application programming interface, API) and a programming framework for applications in the application layer. The application framework layer includes some predefined functions.

As shown in Figure 3, the application framework layer can include a window manager, a content provider, a view system, a phone manager, a resource manager, a notification manager, and so on.

The window manager is used to manage window programs. The window manager can obtain the size of the display screen, determine whether there is a status bar, lock the screen, take a screenshot, etc.

The content provider is used to store and retrieve data and make these data accessible to applications. The data may include video, image, audio, phone calls made and received, browsing history and bookmarks, phone book, etc.

The view system includes visual controls, such as controls that display text, controls that display pictures, and so on. The view system can be used to build applications. The display interface can be composed of one or more views. For example, a display interface that includes a short message notification icon may include a view that displays text and a view that displays pictures.

The phone manager is used to provide the communication function of the electronic device 100. For example, the management of the call status (including connected, hanged up, etc.).

The resource manager provides various resources for the application, such as localized strings, icons, pictures, layout files, video files, and so on.

The notification manager enables the application to display notification information in the status bar, which can be used to convey notification-type messages, and it can disappear automatically after a short stay without user interaction. For example, the notification manager is used to notify download completion, message reminders, and so on. The notification manager can also be a notification that appears in the status bar at the top of the system in the form of a chart or a scroll bar text, such as a notification of an application running in the background, or a notification that appears on the screen in the form of a dialog window. For example, text messages are prompted in the status bar, prompt sounds, electronic devices vibrate, and indicator lights flash.

Android Runtime includes a core library and a virtual machine (the virtual machine can become a java virtual machine, such as the Dalvik virtual machine). Android runtime is responsible for the scheduling and management of the Android system.

The core library consists of two parts: one part is the function functions that the java language needs to call, and the other part is the core library of Android.

The application layer and the application framework layer run in a virtual machine. The virtual machine translates the Java bytecode of the application layer and the application framework layer into a binary executable file. The virtual machine is used to perform functions such as object life cycle management, stack management, thread management, security and exception management, and garbage collection. By way of example, the multithreaded access method in the embodiment of the present application is executed through a virtual machine. Wherein, when the software architecture shown in FIG. 3 is an Android operating system, the virtual machine may be Dalvik/ART, or HUAWEI maple, etc. When the software architecture shown in FIG. 3 is an operating system such as Linux or Windows, the virtual machine may be an openJDK virtual machine.

It should be noted that the virtual machine may be created when the application is started, or it may be pre-installed, which is not limited. For example, in the Android operating system, the virtual machine may be created when the application is started. For another example, in the Widows operating system, the virtual machine can be installed on the electronic device by the user according to his own needs.

The system library can include multiple functional modules. For example: surface manager (surface manager), media library (Media Libraries), three-dimensional graphics processing library (for example: OpenGL ES), 2D graphics engine (for example: SGL), etc.

The surface manager is used to manage the display subsystem and provides a combination of 2D and 3D layers for multiple applications.

The media library supports playback and recording of a variety of commonly used audio and video formats, as well as still image files. The media library can support a variety of audio and video encoding formats, such as: MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, etc.

The 3D graphics processing library is used to realize 3D graphics drawing, image rendering, synthesis and layer processing, etc.

The 2D graphics engine is a drawing engine for 2D drawing.

The kernel layer is the layer between hardware and software. The kernel layer includes at least display driver, camera driver, audio driver, and sensor driver.

First, some terms involved in the embodiments of the present application are explained to facilitate the understanding of those skilled in the art.

1. Lock. The lock in the embodiment of the present application is used to protect shared resources from being accessed by multiple threads at the same time. The shared resources in the embodiments of the present application can be accessed by multiple threads, such as memory, code, variables, or data, which is not limited. For example, a lock may be an object (object, obj) or a part of an object, where the object is used to protect shared resources and is an instance of a class, where the class is a template that describes the behavior and state of a class of objects. For another example, the lock may also be an address or other uniquely determined parameters or structures.

2. The lock state variable (lockword). In the embodiment of the present application, the lockword includes a lock thread identification field, a repeated lock count field, and a blocked thread number field, which may be 32 bits or 64 bits. The embodiment of the present application does not limit the number of bits of the lockword. Further, in some other embodiments, the lockword may also include reserved bits to facilitate subsequent expansion of functions or operations.

Specifically, lockword and lock have a one-to-one correspondence, and different locks have different lockwords. Take the lockword of the target lock as an example.

The lock-holding thread identification field is used to indicate the lock-holding thread of the target lock. For example, taking the first thread as an example, the first thread may obtain the target lock by setting the lock-holding thread identification field to the first thread. Specifically, the first thread may set the lock-holding thread identification field as the first thread by setting the thread ID of the first thread in the lock-holding thread identification field.

The Blocked Threads field is used to indicate the number of threads that are blocked for the target lock.

Further, in some embodiments, the blocked thread number field includes the first value and the high-order flag of the blocked thread number. The first value is the low value of the number of threads in the blocked state for the target lock, and the high bit flag of the number of blocked threads is used to indicate whether the second value corresponding to the ID of the target lock is stored in the high bit list of the number of blocked threads. The second value is the high value of the number of threads in the blocked state for the target lock. This helps to avoid overflow when there are too many threads in a blocked state for the target lock. For example, when the high-order flag of the number of blocked threads is a valid flag, it indicates that the second value corresponding to the ID of the target lock is stored in the high-order list of the number of blocked threads. When the high flag of the number of blocked threads is an invalid flag, it indicates that the second value corresponding to the ID of the target lock is not stored in the high list of the number of blocked threads, or the second value corresponding to the ID of the target lock is 0. For example, when the high flag of the number of blocked threads is set to 1, the high flag of the number of blocked threads is a valid flag. For another example, when the high bit flag of the number of blocked threads is set to 0, that is, the high bit flag of the number of blocked threads is an invalid flag.

For example, the high list of the number of blocked threads may be a global variable and stored in the electronic device in the form of a map. Taking the second value corresponding to the ID of the target lock for example, the format of the second value corresponding to the ID of the target lock stored in the high list of blocked threads is shown in Figure 4, the ID of the target lock is key, and the second value It is vlaue, so that the thread requesting to acquire the target lock can index the second value from the high list of blocked threads through the ID of the target lock.

The number of repeated locks field is used to indicate the number of locks held by the lock-holding thread for the target lock. Specifically, in the embodiment of the present application, the lock-holding thread may indicate the number of lock-holding times of the lock-holding thread for the target lock by setting the repeated lock-holding coefficient domain to the number of times the lock-holding thread repeatedly holds the lock for the target lock. Alternatively, the repeated lock holding coefficient field can also be directly set to the number of times the lock holding thread holds the lock for the target lock. For example, in the case where the number of times the lock-holding thread holds the lock for the target lock is 1, the number of repeated locks held by the lock-holding thread for the target lock is 0, that is, the lock-holding thread can set the repeated lock-holding coefficient domain to 0, or it can Set to 1 to indicate that the number of times the lock-holding thread holds the lock for the target lock is 1. In addition, in some embodiments, the lock-holding thread may indicate that the number of lock-holding times of the target lock by the lock-holding thread is zero by setting the number of repeated locks field to be empty. Alternatively, the lock-holding thread may indicate that the lock-holding number of the target lock by the lock-holding thread is 0 by setting the number of repeated locks field to a specific symbol or value. For example, in the case that the lock-holding thread directly sets the repeated lock-holding coefficient field to the number of locks held by the lock-holding thread for the target lock, the lock-holding thread can indicate the lock-holding thread by setting the number of repeated locks field to 0. The number of holding locks for the target lock is 0. For another example, when the lock-holding thread sets the repeated lock-holding coefficient field to the number of times the lock-holding thread has repeatedly held the lock for the target lock, the lock-holding thread can indicate the lock holding by setting the repeated lock-holding times field to none. The number of times the thread holds the lock for the target lock is 0.

Further, in some embodiments, the repeated lock-holding coefficient field includes a third value and a high-level indicator of the number of repeated lock-holding times. Among them, the third value is the low value of the number of locks held by the lock thread for the target lock, and the high flag of the number of repeated locks is used to indicate whether the ID of the target lock and the lock thread are stored in the high list of the number of repeated locks. The fourth value corresponding to the thread ID of the thread ID, and the fourth value is the high value of the number of times the lock-holding thread holds the lock for the target lock. This helps to avoid overflow when the lock-holding thread locks the target too many times. For example, when the high flag of the number of repeated locks is a valid flag, it indicates that the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread is stored in the high list of the number of repeated locks. When the high flag of the number of repeated locks is an invalid flag, it indicates that the fourth value corresponding to the ID of the target lock and the thread ID of the lock thread is not stored in the high list of the number of repeated locks, or the ID and the lock of the target lock The fourth value corresponding to the thread ID of the thread is 0. For example, when the high flag of the number of repeated locks is set to 1, the high flag of the number of repeated locks is a valid flag. For another example, when the high flag of the number of repeated locks is set to 0, that is, the high flag of the number of repeated locks is an invalid flag.

For example, the high-order list of the number of repeated locks may be a global variable and stored in the electronic device in the form of a map. Taking the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread as an example, the format of the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread stored in the high-order list of the number of repeated locks is as follows As shown in Figure 5, the ID of the target lock and the thread ID of the thread holding the lock are the key, and the fourth value is vlaue, so that the thread requesting to reacquire the target lock can use the ID and thread ID of the target lock from the high list of the number of repeated locks The fourth value of the middle index.

For example, in the case where the lockword is 32 bits, the lockword of the target lock may be as shown in FIG. 6, including a lock thread identification field, a repeated lock count field, a blocked thread number field, and reserved bits. Among them, the domain of the number of repeated locks includes the Counter field and the M1 field, and the field of the number of blocked threads includes the WaitNum field and the M2 field. The Counter field is used to set the first value, and the M1 field is used to set the high-level flag of the number of repeated locks. The WaitNum field is used to set the third value, and the M2 field is used to set the high flag of the number of blocked threads.

As shown in Figure 6, the first 16 bits of the lockword (that is, the 0th to 15th bits) are the lock thread identification field, and the 16th to 18th bits of the lockword are the Counter field. The 19th bit of the lockword is the M1 field. The 20th to 28th bits of the lockword are the WaitNum field, and the 30th and 31st bits are reserved bits. It should be noted that the reserved bits may not be set in the lockword. Or, set the number of bits in each field in the lockword according to actual needs.

It should be noted that FIG. 6 is only an example of the lockword format of the target lock, and does not constitute a limitation on the lockword format. For example, in the embodiment of the present application, the number of bits in each field in the lockword can also be set according to actual needs.

In addition, in other embodiments, the hashcode (hash value) of the target lock is used to indicate whether the target lock exists. Taking the target lock as an object as an example, the hashcode of the target lock is stored in the memory space corresponding to a negative offset of 9 bits from the address of the object header of the object. Or, in the case that the memory space corresponding to the address of the lockword used to store the target lock is empty, the electronic device can store the hashcode of the target lock in the memory space corresponding to the address of the lockword used to store the target lock. Contribute to the rational use of memory space. Further, in the embodiment of the present application, the hashcode of the target lock may be stored in the form of a map. For example, the storage format of the hashcode of the target lock may be as shown in Figure 7, where the ID of the target lock is key and the hashcode is value. Specifically, the thread can index to the hashcode of the target lock through the ID of the target lock.

Taking the electronic device with the structure shown in FIG. 2 and FIG. 3 as an example, the multi-process synchronization method in the embodiment of the present application will be introduced in detail.

Example 1: Take the first thread's request to acquire the target lock as an example. Wherein, the request by the first thread to acquire the target lock can be understood as: the first thread requests to lock the target lock. In some embodiments, when the first thread runs to a function or program instruction requesting to acquire the target lock, the process of executing the first thread's request to acquire the target lock is triggered. For example, the function or program instruction requesting to acquire the target lock is MonitorEnter.

As an example, the first thread requests to acquire the target lock, including the following steps, as shown in FIG. 8 in detail.

Step 801: The first thread acquires the lockword of the target lock.

For example, the first thread obtains the lockword of the target lock according to the address of the target lock. For example, in the case where the lockword is 32 bits, the address of the target lock may be a forward offset of 4 bytes from the address of the object header of the object where the target lock is located.

Step 802: The first thread checks whether the lock-holding thread identification field is a valid thread. That is, the first thread judges whether the lock-holding thread identification field is set as a valid thread. If yes, go to step 803, otherwise go to 809.

It should be noted that the lock-holding thread identification field is not a valid thread, which is equivalent to the lock-holding thread identification field being an invalid thread.

Specifically, setting the lock-holding thread identification field as a valid thread can be understood as: the thread ID set in the lock-holding thread identification field is a valid value. For example, [1,1000] is the effective value of the thread ID, and the thread ID set on the lock-holding thread ID field is in [1,1000], that is, the lock-holding thread field is set as a valid thread. It can be understood that when the thread ID set in the lock-holding thread identification field is not a valid value, it can be understood that the lock-holding thread ID is set to an invalid thread. For example, if the thread ID set in the lock-holding thread identification field is 0 or 1001, and 0 and 1001 are not in [1,1000], the lock-holding thread identification field is set as an invalid thread. It should be noted that when the lock-holding thread identification field is set to an invalid thread, it can be understood that the target lock is in a non-lock state (non_lock).

In other embodiments, the lock-holding thread identification field is set to be an invalid thread, and it can also be implemented by setting a specific value or symbol on the lock-holding thread identification field. For example, when the lock-holding thread identification field is set to NA, it is about to be held. The lock thread ID field is set to an invalid thread.

Step 803: The first thread checks whether the lock-holding thread domain is the first thread, if yes, execute step 808; otherwise, execute step 804.

Step 804: The first thread checks whether the blocked thread number domain is less than the first threshold, if yes, execute step 805, otherwise, execute step 807.

For example, the first threshold may be 3, 4, 5, etc., specifically it may be set before the electronic device leaves the factory, or it may be determined by the electronic device according to its own operating conditions, which is not limited. For example, in the case where the electronic device itself runs fast, the first threshold value may be a larger value, and in the case where the electronic device itself is running stuck, the value of the first threshold value may be smaller.

Step 805: The first thread performs spin waiting.

In some embodiments, the first thread can spin-wait in the following ways:

The first thread calls the sched_yield system function and sends a yield instruction to the processor. After receiving the yield instruction, the processor suspends the first thread for a certain period of time, so that the first thread relinquishes control of the processor for a certain period of time and performs spin waiting.

It should be noted that in the embodiment of the present application, the electronic device may also perform spin waiting in other ways, which is not limited.

Step 806: When the number of spin waiting times of the first thread reaches the second threshold, if it is checked that the lock-holding thread identification field is a valid thread and not the first thread, the first thread performs an operation of adding 1 to the blocked thread number field. And hang into the blocking state.

In some embodiments, the blocked thread number field includes the first value and the high-order flag of the blocked thread number. For details, please refer to the above related introduction. In this case, the operation of adding 1 to the number field of blocked threads by the first thread may be as shown in FIG. 9, and may specifically include the following steps:

Step 901: The first thread checks whether the first value is equal to the first target value, and the first target value is the maximum value in the low order of the number of threads in the blocked state for the target lock. If yes, go to step 903, otherwise, go to step 902.

That is, the first thread compares or judges whether the first value is the same as the first target value.

Step 902: The first thread adds 1 to the first value.

For example, set the low-order value of the number of threads in the blocked state for the target lock on the 3 bits in the lockword. In this case, the first target value is 7. When the first value is 4, the first thread adds 1 to the first value and sets the first value to 5.

Step 903: The first thread checks whether the high-level flag of the number of blocked threads is a valid flag, if yes, execute step 904, otherwise, execute step 905.

It is understandable that the high-level identifier of the number of blocked threads is not a valid identifier, and is equivalent to the invalid identifier of the number of blocked threads.

Step 904: The first thread sets the first value to 0, and adds 1 to the second value corresponding to the ID of the target lock in the blocked thread list.

Step 905: The first thread sets the first value to 0, sets the high flag of the number of blocked threads as a valid flag, sets the second value corresponding to the ID of the target lock to 1, and sets the ID of the target lock and the ID of the target lock The corresponding second value is added or stored in the blocked thread list.

In some embodiments, the first thread can be suspended and enter the blocking state in the following ways:

The first thread makes a system call, sets the state of the first thread to a sleep state, and adds the first thread to the waiting queue corresponding to the address of the target lock. For example, the first thread makes a system call based on the fast user mutex (futex) mechanism, sets the state of the first thread to sleep, and adds the first thread to the address corresponding to the target lock Waiting in the queue. For example, the first thread may suspend and enter the blocking state through the system call futex_wait.

In some other embodiments of the present application, the first thread sets the lock-holding thread identification field to the first thread when the number of spin waits is less than the second threshold, and the first thread has a shared resource protected by the target lock Make a visit.

Step 807: The first thread performs an operation of adding 1 to the blocked thread number field, and suspends and enters a blocking state.

Among them, the first thread performs an operation of adding 1 to the blocked thread number field and suspends and enters the blocking state for a specific implementation manner, which can be referred to the related introduction in step 806, which will not be repeated here.

Step 808: The first thread performs an operation of adding 1 to the repeated lock count field.

In some embodiments, the field of the number of repeated locks includes a third value and a high flag of the number of repeated locks. For details, please refer to the above related introduction. In this case, the operation of adding 1 to the number of repeated lock holdings performed by the first thread may be as shown in FIG. 10, which may specifically include the following steps:

Step 1001: The first thread checks whether the third value is equal to the second target value, and the second target value is the maximum value in the low order of the number of lock holding times of the lock holding thread for the target lock. If yes, go to step 1003; otherwise, go to step 1002.

Step 1002, the first thread adds 1 to the third value.

For example, set the low value of the number of locks held by the lock thread for the target lock on the 5 bits in the lockword. In this case, the second target value is 31. When the third value is 20, the first thread adds 1 to the third value and sets the third value to 21.

Step 1003: The first thread checks whether the high-level flag of the number of repeated locks is a valid flag, if it is, step 1004 is executed, otherwise, step 1005 is executed.

Step 1004: The first thread sets the third value to 0, and adds 1 to the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread in the high list of the number of repeated locks.

Step 1005: The first thread sets the third value to 0, sets the high flag of the number of repeated locks as a valid flag, sets the fourth value corresponding to the ID of the target lock and the thread ID of the lock thread to 1, and sets the target lock The ID of the lock thread, the thread ID of the lock thread, and the fourth value corresponding to the ID of the target lock and the thread ID of the lock thread are added or stored in the blocked thread list.

In step 809, the first thread sets the lock-holding thread identification field as the first thread, and initializes the repeated lock-holding times field.

Wherein, the first thread initializes the repeated lock count field, which can be understood as the first thread sets the repeated lock count field to an initial value. For example, when the initial value is 0, the first thread sets the number of repeated locks field to 0. In the case where the initial value is 1, the first thread sets the number of repeated locks field to 1.

For example, in the case where the lock-holding thread directly sets the repeated lock-holding coefficient domain to the number of times the lock-holding thread holds the target lock, the initial value may be 1. For example, when the lock-holding thread sets the repeated lock-holding coefficient domain to the number of times the lock-holding thread repeatedly holds the target lock, the initial value may be 0.

In the embodiment of the present application, since the number of spin waiting times of the first thread reaches the second threshold, the first thread only needs to perform an operation of adding 1 to the blocked thread number field and suspend into the blocking state. The lock-holding thread of the lock is suspended, and there is no need to allocate a monitor object, which helps to reduce the length of time that the lock-holding thread accesses shared resources, thereby helping to reduce the probability of electronic device jams and improving user experience.

In addition, in the embodiment of the present application, when the first thread is a lock-holding thread, if the target lock is repeatedly held, it is only necessary to add 1 to the number of repeated lock-holding threads, and there is no need to allocate monitor objects and modify the lock status. Therefore, it helps to improve the processing efficiency of the first thread and the operating speed of the electronic device, thereby helping to improve the user experience.

Example 2: Take the first thread's request to release the target lock as an example. In some embodiments, when the first thread runs to a function or program instruction requesting the release of the target lock, the process of executing the first thread's request to release the target lock is triggered. For example, the function or program instruction that requests the release of the target lock is MonitorExit.

For example, the first thread requesting to release the target lock includes the following steps, as shown in FIG. 11 in detail.

Step 1101: The first thread acquires the lockword of the target lock. For details, refer to the related introduction of step 801.

In step 1102, the first thread checks whether the lock-holding thread identification field is the first thread, if so, execute step 1103; otherwise, execute step 1107.

For example, the first thread compares whether the lock-holding thread identification field is the thread ID of the first thread.

In step 1103, the first thread checks whether the repeated lock count field is 0, and if so, execute step 1106; otherwise, execute step 1104.

It should be noted that the number of repeated lock holdings is not 0, which can be understood as the number of lock holding threads for the target lock indicated by the number of repeated locks is greater than 0. The number of repeated locks is 0, which can be understood as the number of locks held by the lock thread indicated by the number of repeated locks for the target lock is 0.

In step 1104, the first thread performs a minus 1 operation on the repeated lock count field.

In some embodiments, the field of the number of repeated locks includes a third value and a high flag of the number of repeated locks. For details, please refer to the above related introduction. In this case, the operation of subtracting 1 from the number of repeated lock holdings by the first thread may be as shown in FIG. 12, which may specifically include the following steps:

Step 1201: The first thread checks whether the third value is 0, that is, the first thread determines whether the number of times the lock holding thread (ie, the first thread) holds the target lock is 0. If not, step 1202 is performed, and if yes, step 1203 is performed.

Step 1202, the first thread subtracts 1 from the third value.

For example, set the low value of the number of locks held by the lock thread for the target lock on the 5 bits in the lockword. In this case, when the third value is 20, the first thread subtracts 1 from the third value and sets the third value to 19.

Step 1203: The first thread checks whether the high-level flag of the number of repeated locks is a valid flag, if it is, step 1204 is executed, otherwise, step 1207 is executed.

Step 1204: The first thread checks whether the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread in the high list of the number of repeated locks is 1, if yes, execute step 1205, otherwise, execute step 1206.

It should be noted that the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread in the high list of the number of repeated locks is not 1, which can be understood as the ID and hold of the target lock in the high list of the number of repeated locks. The fourth value corresponding to the thread ID of the locked thread is greater than 1.

Step 1205: The first thread sets the third value to the second target value, and deletes the ID of the target lock, the thread ID of the lock-holding thread and the thread ID of the target lock and the thread ID of the lock-holding thread in the high list of repeated locks. The fourth value of, and the high flag of the number of repeated locks is set to an invalid flag.

Step 1206: The first thread sets the third value to the second target value, and subtracts 1 from the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread.

Step 1207: The first thread throws an exception.

Step 1105: After the first thread performs an operation of subtracting 1 from the number of repeated locks field, the first thread rechecks whether the number of repeated locks field is 0, if so, execute step 1106, otherwise the process ends.

Step 1106: The first thread sets the lock thread identification field as an invalid thread, and checks whether the blocked thread number field is 0, if not, execute step 1107, otherwise the process ends.

Step 1107: The first thread wakes up N threads that are blocked for the target lock. Further, after the first thread wakes up the N threads in the blocked state of the target lock, it may also perform an operation of subtracting N on the blocked thread number field. Or, the first thread wakes up N threads that are blocked for the target lock, and does not perform the N reduction operation on the blocked thread number field. When one of the N threads sets the lock-holding thread identification field to this thread, the The thread performs the operation of subtracting 1 from the blocked thread number field, and the other N-1 threads among the N threads can be suspended again and enter the blocking state. For example, when the third thread among the N threads sets the lock-holding thread identification field to the third thread, the third thread performs an operation of subtracting 1 on the blocked thread number field.

Among them, N is a positive integer greater than or equal to 1. For example, N can be 1 or 2, or 3, or the number of all threads that are blocked for the target lock. Among them, the value of N can be preset in the code by the developer as needed.

In some embodiments, the first thread may wake up at least one thread that is blocked for the target lock based on the following methods:

The first thread makes a system call, sets the state of at least one thread in the waiting queue corresponding to the address of the target lock to the running state, and adds at least one thread to the run queue corresponding to the address of the target lock; The waiting queue corresponding to the address of includes at least one thread that is blocked for the target lock.

For example, the first thread may make a system call based on the futex mechanism to wake up at least one thread that is blocked for the target lock. For example, the first thread system calls futex_wake to wake up at least one thread that is blocked for the target lock.

Step 1108: The first thread checks whether the lock-holding thread identification field is an invalid thread, if yes, execute step 1109, otherwise, execute step 1110.

Step 1109: The first thread throws a no-lock exception.

Step 1110, the first thread throws an other-lock exception.

Example 3: Take the first thread's request to suspend the lock on the target as an example. Wherein, the request of the first thread to suspend the lock lock on the target can be understood as: the first thread actively requests to give up the lock lock on the target when the lock is locked on the target and the target lock is not released. In some embodiments, when the first thread runs to a function or program instruction that requests to suspend the lock on the target, it triggers the execution of the process in which the first thread requests to suspend the lock on the target. For example, the function or program instruction requesting to suspend the lock on the target is MonitorWait.

As an example, the first thread requests to suspend the lock on the target, including the following steps, as shown in FIG. 13 specifically.

Step 1301: The first thread acquires the lockword of the target lock. For details, please refer to the related introduction in step 801, which will not be repeated here.

Step 1302, the first thread checks whether the lock-holding thread identification field is the first thread, if yes, execute step 1303, otherwise exit.

Step 1303: The first thread saves the repeated lock count field as the context of the first thread for the target lock.

Wherein, the first thread saves the field of the number of repeated locks as the context of the first thread for the target lock, which can be understood as: the first thread saves the number of locks for the target lock as the context of the first thread for the target lock.

For example, in the case that the repeated lock count field includes the third value and the high mark of the repeated lock count, and the high mark of the repeated lock count is the valid mark, the first thread saves the lock count for the target lock as the first The context of the thread for the target lock can mean that the first thread sets the third value, the high mark of the number of repeated locks, and the first thread ID corresponding to the ID of the target lock and the thread ID of the lock-holding thread in the high list of the third value, the number of repeated locks. The four value is saved as the context of the first thread for the target lock. Alternatively, the first thread determines the fifth value according to the third value, the high flag of the number of repeated locks, and the fourth value corresponding to the ID of the target lock and the thread ID of the lock-holding thread in the high list of the number of repeated locks, where the fifth The value is the number of times the first thread holds the lock for the target lock, and the fifth value is saved as the context of the first thread for the target lock.

For example, the third value is 7, the high mark of the repeated lock coefficient is a valid mark, and the fourth value corresponding to the ID of the target lock and the thread ID of the lock thread in the high list of the number of repeated locks is 1. In the case where the maximum value in the low order of the number of holding times of the target lock is 7, the fifth value is 15. The first thread may save 15 as the context of the first thread for the target lock, or it may save 7, the high bit flag of the repeated lock holding coefficient and 1 as the context of the first thread for the target lock.

As another example, in the case that the repeated lock count field includes the third value and the high mark of the repeated lock count, and the high mark of the repeated lock count is the invalid mark, the first thread saves the lock count for the target lock as the first The context of a thread for the target lock can mean that the first thread saves the third value as the context of the first thread for the target lock, or the first thread saves the third value and the high-level identifier of the number of repeated locks as the first The context of the thread for the target lock.

For example, the first thread may store the context of the first thread for the target lock in a designated storage space.

Step 1304: The first thread adds the thread ID of the first thread to the thread waiting list corresponding to the ID of the target lock.

For example, the first thread can add the thread ID of the first thread to the thread waiting list corresponding to the ID of the target lock in the following manner:

First, the first thread looks up the thread waiting list corresponding to the ID of the target lock according to the ID of the target lock. If the first thread does not find the thread waiting list corresponding to the ID of the target lock, the first thread creates a thread waiting list corresponding to the ID of the target lock, and adds the thread ID of the first thread to the ID corresponding to the target lock Thread waiting list. If the first thread finds the thread waiting list corresponding to the ID of the target lock, the first thread adds the thread ID of the first thread to the thread waiting list corresponding to the ID of the target lock.

In some embodiments, the thread waiting list corresponding to the ID of the target lock may be a global variable and stored in the electronic device in the form of a single necklace. Taking the thread ID of the first thread as an example, the format of the thread ID of the first thread stored in the thread waiting list corresponding to the ID of the target lock can be as shown in Figure 14. The ID of the target lock is the key, and the thread ID of the first thread Is the value. Therefore, the thread ID of the first thread can be indexed from the thread waiting list corresponding to the ID of the target lock by the ID of the target lock.

Step 1305: The first thread sets the number of repeated locks field to 0, and sets the lock thread identification field to be an invalid thread, and suspends and enters a blocking state. Therefore, when the first thread locks the target but does not release the lock, it actively gives up control of the target lock, so that other threads, especially threads with a higher business priority than the first thread, can achieve priority locks. Shared resource access to meet the needs of users.

Specifically, that the first thread sets the number of repeated locks field to 0 means that the first thread clears the number of locks indicated by the number of repeated locks field to 0. For example, in the case that the number of repeated locks field includes the third value and the high flag of the number of repeated locks, and the high flag of the number of repeated locks is a valid flag, the first thread sets the number of repeated locks field to 0, which means: A thread sets the third value to 0, sets the high flag of the number of repeated locks to an invalid flag, and sets the fourth value corresponding to the ID of the target lock and the thread ID of the first thread in the high list of the number of repeated locks to 0.

It should be noted that, for the specific implementation manner of the first thread suspending and entering the blocking state, refer to the related introduction in step 805, which will not be repeated here.

Further, if the first thread is awakened again after performing step 1305, the first thread may request to acquire the target lock again, which specifically includes the following steps:

Step 1306: The first thread reacquires the lock state variable of the target lock.

In step 1307, the first thread checks whether the lock-holding thread identification field is an invalid thread, and if so, executes step 1308; otherwise, it continues to check whether the lock-holding thread identification field is an invalid thread.

In step 1308, the first thread sets the lock-holding thread identification field as the first thread, and sets the repeated lock-holding times field according to the context of the first thread for the target lock.

For example, the context of the first thread for the target lock includes that the number of locks held by the first thread for the target lock is 15, and the first thread sets the number of repeated locks field to 14 or 15. Specifically, when the lock-holding thread sets the repeated lock-holding coefficient field for the number of repeated locks of the target lock, the first thread sets the repeated lock-holding number field to 14; by setting the lock-holding thread to hold the lock for the target lock In the case of setting the repeated lock-holding coefficient field for the number of times, the first thread sets the repeated lock-holding times field to 15.

Further, in some embodiments, the field of the number of repeated locks includes a third value and a high flag of the number of repeated locks. When the third value is set by 3 bits in the repeated lock count field, if the first thread's context for the target lock includes the first thread's lock count for the target lock, the first thread sets the third value to 6 or 7, set the high flag of the number of repeated locks to the effective flag, and set the fourth value corresponding to the ID of the target lock and the thread ID of the first thread to 1, and set the ID of the target lock and the thread of the first thread The ID and the fourth value corresponding to the ID of the target lock and the thread ID of the first thread are added or stored in the high list of the number of repeated locks.

Step 1309: The first thread deletes the thread ID of the first thread in the thread waiting list corresponding to the ID of the target lock.

For example, as shown in FIG. 15, the first thread deleting the thread ID of the first thread in the thread waiting list corresponding to the ID of the target lock may specifically include the following steps:

Step 1501, the first thread searches for a thread waiting list corresponding to the ID of the target lock according to the ID of the target lock.

Step 1502, if the first thread does not find the thread waiting list corresponding to the ID of the target lock, it will hang abnormally.

Step 1503: If the first thread finds the thread waiting list corresponding to the ID of the target lock, the first thread searches for the thread ID of the first thread from the thread waiting list corresponding to the ID of the target lock.

Step 1504: If the first thread finds the thread ID of the first thread, the first thread deletes the thread ID of the first thread.

Step 1505: If the first thread does not find the thread ID of the first thread, the first thread hangs abnormally.

In addition, threads that voluntarily give up holding the target lock can be awakened in the following ways:

Method 1: The second thread searches the thread waiting list corresponding to the ID of the target lock according to the ID of the target lock. After finding the thread waiting list corresponding to the ID of the target lock, the second thread checks the thread waiting list corresponding to the ID of the target lock. If the second thread checks that the thread waiting list corresponding to the ID of the target lock is not empty, that is, the thread ID is stored in the thread waiting list corresponding to the ID of the target lock, the second thread waits from the thread corresponding to the ID of the target lock Select at least one thread ID from the list, and wake up the thread identified by the at least one thread ID.

Wherein, the second thread may be a thread that belongs to the same process and is in a running state, and threads identified by one or more thread IDs in the thread waiting list corresponding to the ID of the target lock. The second thread can check whether the thread waiting list corresponding to the ID of the target lock is empty every certain period of time.

For example, the second thread selects the first thread ID from the thread waiting list corresponding to the ID of the target lock, and wakes up the thread identified by the first thread ID. In the case where the first thread ID indicates the first thread, the first thread is awakened.

Method 2: When the system checks or detects that the thread ID of the first thread is in the thread waiting list corresponding to the ID of the target lock, the system suspends the first thread and enters the blocking state to start the timer, and after the timer reaches the specified duration , Wake up the first thread.

The foregoing is only an example of the wake-up method for the thread that actively abandons the target lock, and does not constitute a limitation on the wake-up method for the thread that actively abandons the target lock.

In addition, it can be understood that when the first thread requests to suspend the lock on the target, if the interrupt state of the first thread changes, an exception is thrown. For example, when the first thread suspends and enters the blocking state in the execution of step 1305, if the interrupt state of the first thread changes, an exception is thrown and the subsequent steps are not executed. For another example, when the first thread is awakened, if the interrupt state of the first thread changes, an exception is thrown, and the subsequent steps are not continued.

The following describes the multi-thread synchronization method of the embodiment of the present application in combination with specific scenarios.

Take the target lock as lock 1 as an example. For example, for lock 1, the lock-holding thread is thread 2, and while thread 2 requests to release lock 1, thread 1 can request to acquire lock 1, where thread 1 is a non-lock-holding thread of lock 1. In this case, as shown in Figure 16, thread 1 requests to acquire lock 1 and thread 2 requests to release lock 1 specifically including the following steps:

Step 1601_1, thread 1 obtains the lock state variable of lock 1; step 1601_2, thread 2 obtains the lock state variable of lock 1.

Step 1602_1: Thread 1 checks that the lock-holding thread identification field is thread 2, and checks whether the blocked thread number field is less than the first threshold. If yes, execute step 1603_1; otherwise, execute step 1605_1.

Step 1603_1: Thread 1 performs spin waiting.

Step 1604_1. When the number of spin waits for thread 1 reaches the second threshold, if it is checked that the lock-holding thread identification field is a valid thread and not the first thread, thread 1 performs an increment operation on the blocked thread number field and suspends the entry Blocked state.

Step 1605_1: Thread 1 performs an operation of adding 1 to the blocked thread number field, and suspends and enters a blocking state.

Step 1602_2, thread 2 checks that the lock thread identification field is thread 2, and checks whether the repeated lock count field is 0, if it is not 0, execute step 1603_2, otherwise execute step 1605_2.

Step 1603_2, Thread 2 performs a minus 1 operation on the repeated lock count field.

Step 1604_2, thread 2 rechecks whether the repeated lock count field is 0, if yes, execute step 1605_2, otherwise thread 2 continues to hold lock 1.

Step 1605_2, thread 2 sets the lock-holding thread identification field to an invalid thread, and checks whether the blocked thread number field is 0, if yes, execute step 1606_2, otherwise the process ends.

Step 1606_2, thread 2 wakes up at least one thread that is blocked for the target lock.

It should be noted that step 1605_2 is executed after checking that the lock-holding thread identification field is thread 2 in step 1602_1.

Take the target lock as lock 1 as an example. For example, for lock 1, the lock holding thread is thread 2, and while thread 2 requests to acquire lock 1 again, thread 1 can request to acquire lock 1, where thread 1 is a non-lock holding thread of lock 1. In this case, as shown in Figure 17, the thread 1 requesting lock 1 and the thread 2 requesting lock 1 again specifically include the following steps:

Step 1701_1, thread 1 obtains the lock state variable of lock 1; step 1701_2, thread 2 obtains the lock state variable of lock 1.

Step 1702_1: Thread 1 checks that the lock-holding thread identification field is thread 2, and checks whether the blocked thread number field is less than the first threshold. If yes, execute step 1703_1; otherwise, execute step 1705_1.

Step 1703_1: Thread 1 performs spin waiting.

Step 1704_1. When the number of spin waits for thread 1 reaches the second threshold, if it is checked that the lock-holding thread identification field is a valid thread and not the first thread, thread 1 performs an increment operation on the blocked thread number field and suspends the entry Blocked state.

Step 1705_1: Thread 1 performs an operation of adding 1 to the blocked thread number field, and suspends and enters a blocking state.

Step 1702_2, thread 2 checks that the lock-holding thread identification field is thread 2, and performs an operation of adding 1 to the repeated lock-holding times field.

For example, the lock state variable of lock 1 is shown in Figure 18, the number of blocked threads is N1, the number of repeated locks is N2, the first threshold is L1, and the second threshold is L2. At the same time when thread 2 requests to release lock 1, thread 1 You can request to acquire a lock. 1 The changes in different fields of the lock state variable at different times can be seen in Table 1, Table 2 and Table 3. For the description in Table 1, the lock-holding thread identification domain is abbreviated as domain 1, the repeated lock-holding identification domain is abbreviated as domain 2, and the blocking thread identification domain is abbreviated as domain 3.

Table 1

Table 2

table 3

It should be noted that the above description of the multi-thread synchronization method is based on the thread as an example. When the smallest unit of program execution is a smaller or larger granularity than the thread, the threads involved above can also be replaced by the program execution The smallest unit is not limited.

The above embodiments can be used alone or in combination with each other to achieve different technical effects.

In the above-mentioned embodiments provided in the present application, the method provided in the embodiments of the present application is introduced from the perspective of the mobile phone as the execution subject. In order to realize the functions in the methods provided in the above embodiments of the present application, the mobile phone may include a hardware structure and/or a software module, and the above functions are implemented in the form of a software module or a hardware structure combined with a software module. Whether a certain function of the above-mentioned functions is executed by a hardware structure, a software module, or a hardware structure plus a software module depends on the specific application and design constraint conditions of the technical solution.

As shown in FIG. 19, an embodiment of the present application discloses an electronic device 1900. The electronic device 1900 may include: one or more processors 1901 and a memory 1902. The above-mentioned devices can be connected through one or more communication buses. The program instructions are stored in the aforementioned memory 1902 and configured to be executed by the one or more processors 1901 to implement the multi-thread synchronization method shown in FIGS. 8-13 and 15-17 in the embodiments of the present application.

The processors involved in the above embodiments may be general-purpose processors, digital signal processors (digital signal processors, DSP), application specific integrated circuits (ASICs), ready-made programmable gate arrays (field programmable gate arrays, FPGAs). ) Or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components. The methods, steps, and logical block diagrams disclosed in the embodiments of the present application can be implemented or executed. The general-purpose processor may be a microprocessor or the processor may also be any conventional processor or the like. The steps of the method disclosed in the embodiments of the present application can be directly embodied as being executed and completed by a hardware decoding processor, or executed and completed by a combination of hardware and software modules in the decoding processor. The software module can be located in random access memory (RAM), flash memory, read-only memory (read-only memory, ROM), programmable read-only memory or electrically erasable programmable memory, registers, etc. mature in the field Storage medium. The storage medium is located in the memory, and the processor reads the instructions in the memory and completes the steps of the above method in combination with its hardware.

Specifically, for the specific implementation of the above-mentioned electronic device 1900, reference may be made to the related introduction in the method section, and details are not described herein again.

A person of ordinary skill in the art may realize that the units and algorithm steps of the examples described in combination with the embodiments disclosed herein can be implemented by electronic hardware or a combination of computer software and electronic hardware. Whether these functions are performed by hardware or software depends on the specific application and design constraint conditions of the technical solution. Professional technicians can use different methods for each specific application to achieve the described functions.

Those skilled in the art can clearly understand that, for the convenience and conciseness of description, the specific working process of the system, device and unit described above can refer to the corresponding process in the foregoing method embodiment, which will not be repeated here.

In the several embodiments provided in this application, it should be understood that the disclosed system, device, and method may be implemented in other ways. For example, the device embodiments described above are merely illustrative, for example, the division of the units is only a logical function division, and there may be other divisions in actual implementation, for example, multiple units or components may be combined or It can be integrated into another system, or some features can be ignored or not implemented. In addition, the displayed or discussed mutual coupling or direct coupling or communication connection may be indirect coupling or communication connection through some interfaces, devices or units, and may be in electrical, mechanical or other forms.

The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the objectives of the solutions of the embodiments.

In addition, the functional units in the various embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units may be integrated into one unit.

If the function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer readable storage medium. Based on this understanding, the technical solution of the present application essentially or the part that contributes to the existing technology or the part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including A number of instructions are used to make a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor (processor) execute all or part of the steps of the methods described in the various embodiments of the present application. The aforementioned storage media include: U disk, mobile hard disk, ROM, RAM, magnetic disk or optical disk and other media that can store program codes.

The above are only specific implementations of this application, but the protection scope of this application is not limited to this. Any person skilled in the art can easily think of changes or substitutions within the technical scope disclosed in this application, All should be covered within the protection scope of this application, so the protection scope of this application should be subject to the protection scope of the claims.

Claims

A multi-thread synchronization method, characterized in that the method includes:

The first thread requests to acquire the target lock, including:

Step 1. The first thread acquires the lock state variable of the target lock, where the lock state variable includes a lock-holding thread identification field and a blocked thread number field, and the lock-holding thread identification field is used to indicate the target The lock-holding thread of the lock, where the blocked thread count field is used to indicate the number of threads that are in a blocked state for the target lock;

Step 2: The first thread checks the lock-holding thread identification field:

Step 3: If the first thread checks that the lock-holding thread identification field is a valid thread and not the first thread, the first thread checks the blocked thread number field;

Step 4: If the first thread checks that the blocked thread number domain is less than a first threshold, the first thread performs spin waiting;

Step 5. When the number of spin waits for the first thread reaches the second threshold, if the lock-holding thread identification field is checked as a valid thread and not the first thread, the first thread blocks the The thread number field executes the increment operation, and suspends and enters the blocking state.
The method according to claim 1, characterized in that, after the step three, the method further comprises:

Step 6. If the first thread checks that the blocked thread number field is greater than or equal to the first threshold, the first thread performs an increment operation on the blocked thread number field and suspends and enters a blocking state.
The method according to claim 1 or 2, wherein the lock state variable further comprises a repeated lock count field, and the repeated lock count field is used to indicate the number of times the lock holding thread holds the lock for the target lock .
The method according to claim 3, characterized in that, after the step two, the method further comprises:

Step 7. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread performs an increment operation on the number of repeated lock-holding times field.
The method according to claim 3, characterized in that, after the step two, the method further comprises:

Step 8. If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread and sets the number of repeated locks The domain is set to the initial value.
The method of claim 3, wherein the method further comprises:

The request by the first thread to release the target lock includes

Step 9. The first thread acquires the lock state variable of the target lock:

Step 10. The first thread checks the lock thread identification field;

Step eleven, if the first thread checks that the lock-holding thread identification field is the first thread, the first thread checks the repeated lock-holding times field;

Step 12. If the first thread checks that the number of repeated locks field is not 0, the first thread performs a subtraction operation on the number of repeated locks field.
The method according to claim 6, characterized in that, after the step twelve, the method further comprises:

Step 13. If the first thread checks that the number of repeated locks field is 0, the first thread sets the lock thread identification field as an invalid thread;

Step 14. The first thread checks the blocked thread number field;

Step 15. If the first thread checks that the blocked thread count field is not 0, the first thread wakes up at least one thread that is blocked for the target lock.
The method of claim 3, wherein the method further comprises:

The request by the first thread to suspend the locking of the target includes:

Step 16. The first thread acquires the lock state variable of the target lock;

Step 17. The first thread checks the lock-holding thread identification field;

Step 18. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread saves the repeated lock-holding times field as the context of the first thread for the target lock ；

Step 19: The first thread adds the thread identification ID of the first thread to the thread waiting list corresponding to the ID of the target lock;

Step 20: The first thread sets the number of repeated locks field to 0, and sets the lock thread identification field as an invalid thread, and suspends and enters a blocking state.
The method according to claim 8, characterized in that, after the step 20, the method further comprises:

Step 21: After being awakened, the first thread acquires the lock state variable of the target lock;

Step 22: The first thread checks the lock thread identification field;

Step 23: If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread, and according to the first thread For the context of the target lock, the thread sets the repeated lock count field;

Step 24: The first thread deletes the thread ID of the first thread in the thread waiting list corresponding to the ID of the target lock.
The method according to claim 9, wherein the step 21 comprises:

The first thread acquires the lock state variable of the target lock after being awakened by the second thread, wherein the second thread is when the thread waiting list corresponding to the ID of the target lock stores the first thread When the thread ID of a thread, wake up the second thread; the second thread and the first thread belong to the same process; or,

The first thread is awakened by the system when the suspended duration exceeds a third threshold, and acquires the lock state variable of the target lock.
The method according to any one of claims 1 to 10, wherein the field of the number of blocked threads includes a first value and a high-order flag of the number of blocked threads, and the first value is a thread that is in a blocked state for the target lock The high-order flag of the number of blocked threads is used to indicate whether a second value corresponding to the ID of the target lock is stored in the high-order list of the number of blocked threads, and the second value is for the target lock The high value of the number of threads in a blocked state.
The method according to any one of claims 3 to 10, wherein the domain of the number of repeated locks includes a third value and a high flag of the number of repeated locks, and the third value is the lock-holding thread for the target lock The low value of the number of lock holding times, the high bit identifier of the number of repeated lock times is used to indicate whether the fourth value corresponding to the ID of the target lock and the thread ID of the lock thread is stored in the high list of the number of times of repeated lock The fourth value is a high value of the number of lock holding times of the lock holding thread for the target lock.
The method according to any one of claims 1 to 12, wherein the suspending of the first thread and entering the blocking state comprises:

The first thread makes a system call, sets the state of the first thread to a sleep state, and adds the first thread to the waiting queue corresponding to the address of the target lock.
An electronic device, wherein the electronic device includes a processor and a memory, and the memory stores program instructions; the processor calls the program instructions for a first thread to request to acquire a target lock;

The request by the first thread to acquire the target lock includes:

Step 1. The first thread acquires the lock state variable of the target lock, where the lock state variable includes a lock-holding thread identification field and a blocked thread number field, and the lock-holding thread identification field is used to indicate the target The lock-holding thread of the lock, where the blocked thread count field is used to indicate the number of threads that are in a blocked state for the target lock;

Step 2: The first thread checks the lock-holding thread identification field:

Step 3: If the first thread checks that the lock-holding thread identification field is a valid thread and not the first thread, the first thread checks the blocked thread number field;

Step 4: If the first thread checks that the blocked thread number domain is less than a first threshold, the first thread performs spin waiting;

Step 5. When the number of spin waits for the first thread reaches the second threshold, if the lock-holding thread identification field is checked as a valid thread and not the first thread, the first thread blocks the The thread number field executes the increment operation, and suspends and enters the blocking state.
The electronic device according to claim 14, characterized in that, after the step three, it further comprises:

Step 6. If the first thread checks that the blocked thread number field is greater than or equal to the first threshold, the first thread performs an increment operation on the blocked thread number field and suspends and enters a blocking state.
The electronic device according to claim 14 or 15, wherein the lock state variable further comprises a repeated lock hold count field, and the repeated lock hold count field is used to indicate the lock holding thread for the target lock. frequency.
The electronic device according to claim 16, characterized in that, after the step two, it further comprises:

Step 7. If the first thread checks that the lock-holding thread identification field is the first thread, the first thread performs an increment operation on the number of repeated lock-holding times field.
The electronic device according to claim 16, characterized in that, after the step two, it further comprises:

Step 8. If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread and sets the number of repeated locks The domain is set to the initial value.
The electronic device according to claim 16, wherein the processor calls the program instructions and is also used by the first thread to request the release of the target lock:

The request by the first thread to release the target lock includes

Step 9. The first thread acquires the lock state variable of the target lock:

Step 10. The first thread checks the lock thread identification field;

Step eleven, if the first thread checks that the lock-holding thread identification field is the first thread, the first thread checks the repeated lock-holding times field;

Step 12. If the first thread checks that the number of repeated locks field is not 0, the first thread performs a subtraction operation on the number of repeated locks field.
The electronic device according to claim 19, characterized in that, after the step twelve, it further comprises:

Step 13. If the first thread checks that the number of repeated locks field is 0, the first thread sets the lock thread identification field as an invalid thread;

Step 14. The first thread checks the blocked thread number field;

Step 15. If the first thread checks that the blocked thread count field is not 0, the first thread wakes up at least one thread that is blocked for the target lock.
The electronic device according to claim 16, wherein the processor calls the program instructions and is further used for the first thread to request suspension of the lock lock on the target:

The request by the first thread to suspend the locking of the target includes:

Step 16. The first thread acquires the lock state variable of the target lock;

Step 17. The first thread checks the lock-holding thread identification field;

Step 18. If the first thread checks that the lock-holding thread identification field is the first thread, save the repeated lock-holding times field as the context of the first thread for the target lock;

Step 19: The first thread adds the thread identification ID of the first thread to the thread waiting list corresponding to the ID of the target lock;

Step 20: The first thread sets the number of repeated locks field to 0, and sets the lock thread identification field as an invalid thread, and suspends and enters a blocking state.
The electronic device according to claim 21, characterized in that, after the step 20, it further comprises:

Step 21: After being awakened, the first thread acquires the lock state variable of the target lock;

Step 22: The first thread checks the lock thread identification field;

Step 23: If the first thread checks that the lock-holding thread identification field is an invalid thread, the first thread sets the lock-holding thread identification field to the first thread, and according to the first thread For the context of the target lock, the thread sets the repeated lock count field;

Step 24: The first thread deletes the thread ID of the first thread in the thread waiting list corresponding to the ID of the target lock.
The electronic device of claim 22, wherein the step 21 comprises:

The first thread acquires the lock state variable of the target lock after being awakened by the second thread, wherein the second thread is when the thread waiting list corresponding to the ID of the target lock stores the first thread When the thread ID of a thread, wake up the second thread; the second thread and the first thread belong to the same process; or,

The first thread is awakened by the system when the suspended duration exceeds a third threshold, and acquires the lock state variable of the target lock.
The electronic device according to any one of claims 14 to 23, wherein the blocked thread number field comprises a first value and a high-order flag of the blocked thread number, and the first value is a value for the target lock in a blocked state The low-order value of the number of threads, the high-order flag of the number of blocked threads is used to indicate whether a second value corresponding to the ID of the target lock is stored in the high-order list of the number of blocked threads, and the second value is for the target The high value of the number of threads whose lock is in a blocked state.
The electronic device according to any one of claims 16 to 24, wherein the domain of the number of repeated locks includes a third value and a high flag of the number of repeated locks, and the third value is that the lock-holding thread targets the target The value of the low-order value of the number of lock holdings, the high-order flag of the number of repeated locks is used to indicate whether the high-order list of the number of repeated locks stores the fourth corresponding to the ID of the target lock and the thread ID of the lock-holding thread The fourth value is the high value of the number of lock holding times of the lock holding thread for the target lock.
The electronic device according to any one of claims 14 to 25, wherein the suspension of the first thread into a blocking state comprises:

The first thread makes a system call, sets the state of the first thread to a sleep state, and adds the first thread to the waiting queue corresponding to the address of the target lock.
A chip, characterized in that the device is coupled with a memory, so that the device calls the program instructions stored in the memory during operation, so that an electronic device executes the method according to any one of claims 1 to 13.
A computer-readable storage medium, wherein the computer-readable storage medium includes program instructions, when the program instructions run on the electronic device, the electronic device executes any of claims 1 to 13 One described method.