WO2019052576A1

WO2019052576A1 - Synchrolock-based multi-thread processing method, terminal and storage medium

Info

Publication number: WO2019052576A1
Application number: PCT/CN2018/106215
Authority: WO
Inventors: 涂斌健; 陈东持
Original assignee: 惠州Tcl移动通信有限公司
Priority date: 2017-09-18
Filing date: 2018-09-18
Publication date: 2019-03-21
Also published as: CN107729129A

Abstract

A synchrolock-based multi-thread processing method, a terminal and a storage medium. The multi-thread processing method comprises: when multiple threads access the same data resource, ordering the multiple threads according to access time, and successively accessing a pre-set synchrolock according to the order (S10); and by means of the synchrolock, controlling a thread, having a write permission, to access the same data resource alone and continuous multiple threads, having a read permission, to simultaneously access the same data resource (S20). An access permission is set for multiple threads via a synchrolock; a thread having a write permission accesses the same data resource alone, and continuous multiple threads having a read access permission can simultaneously access the same data resource; as such, not only is the security requirement of multiple threads accessing the same data resource satisfied, but also the speed of multi-thread processing can be improved, reducing blockage time of multiple threads.

Description

Multi-thread processing method based on synchronous lock, terminal and storage medium

Technical field

The present invention relates to the field of intelligent terminal technologies, and in particular, to a synchronization lock based multi-thread processing method, a terminal, and a storage medium.

Background technique

In recent years, processor vendors have been limited by power consumption and temperature, and in order to keep high-performance computing growing, computers have moved toward multicore computer architectures. To take full advantage of the multi-core architecture, the application is split into multiple threads that can run independently on a single CPU, so that the design program can be executed in parallel to improve overall operational efficiency. However, when multiple threads are used to access the same data, security problems are prone to occur. For example, multithreading is problematic in that data is inconsistent or inaccurate when the same data is manipulated.

In order to solve the above problem, the synchronization mechanism is generally used to control access of multiple threads to the same data resource, so that when multiple threads access the same data resource at the same time, the same data resource is guaranteed to be exclusively occupied by one thread at a time. However, when the number of multi-threads accessing the same resource is large, the blocking time is too long, and even the jamming and the application are unresponsive.

Therefore, the prior art has yet to be improved and improved.

Summary of the invention

The technical problem to be solved by the present invention is to provide a multi-thread processing method based on a synchronization lock, a terminal, and a storage medium, in order to solve the problem that the existing multi-thread accessing the same data resource has a long clogging time. problem.

In order to solve the above technical problem, the technical solution adopted by the present invention is as follows:

A synchronization lock based multi-thread processing method, comprising:

When the multi-thread accesses the same data resource, the multi-threads are sorted according to the access time, and the preset synchronization locks are sequentially accessed according to the sorting;

When the first thread accesses the synchronization lock, detecting the access permission that the first thread needs to obtain, wherein the access permission includes a read access right and a write access right;

When the first thread needs to acquire read access rights, detecting whether the first thread has write access rights;

If the first thread has write access rights, configure read access rights for the first thread, and control the first thread to access the same data resource.

The cascode-based multi-thread processing method, wherein the multi-thread processing method further includes:

If the first thread does not have write access rights, detecting whether the same data resource is in a state accessed by the first write access thread;

If the same data resource is not in the access state by the first write access thread, detecting whether there is a second write access thread in the waiting state;

When the second write access thread does not exist, configuring write access rights for the first thread, and controlling the first thread to access the same data resource;

The first thread thread sleep state is controlled when there is a second write access thread.

If the same data resource is in the access state by the first write access thread, determining whether the first thread is the same as the first write access thread;

If the first thread is the same as the first write access thread, configuring read access rights for the first thread, and controlling the first thread to access the same data resource, and the first thread The number of visits is increased by one;

If the first thread is different from the first write access thread, controlling the first thread to enter a sleep state.

When the first thread needs to obtain write access rights, detecting whether the same data resource is in an idle state;

When the same data resource is in an idle state, configuring write access rights for the first thread and controlling the first thread to access the same data resource.

Determining, when the same data resource is not in an idle state, a type of a second thread accessing the same data resource, where the type includes a read access thread and a write access thread;

If the type of the second thread is a read access thread, the first thread is controlled to enter a wait state.

If the type of the second thread is a write access thread, detecting whether the first thread is the same as the second thread;

If the first thread is the same as the second thread, configure write access rights for the first thread, and control the thread to access the same data resource, and increase the number of accesses of the thread by one;

If the first thread is different from the second thread, controlling the first thread to enter a waiting state.

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one and the thread in the dormant state is woken up.

A storage medium storing a plurality of instructions adapted to be loaded by a processor and to perform a synchronization lock based multi-thread processing method as described above.

A mobile terminal includes:

a processor adapted to implement each instruction;

A storage device adapted to store a plurality of instructions adapted to be loaded by the processor and to perform a synchronization lock based multi-thread processing method as described above.

Advantageous Effects: Compared with the prior art, the present invention provides a synchronization lock based multi-thread processing method, a terminal, and a storage medium, the multi-thread processing method including: when a multi-thread accesses the same data resource, the The multi-threads are sorted according to the access time, and sequentially access the preset synchronization locks according to the sorting; the synchronization lock controls the thread having the write permission to access the same data resource separately, and the continuous multi-thread with the read permission simultaneously accesses the same data Resources. The invention sets the access authority for the multi-thread by the synchronization lock, and accesses the same data resource separately for the thread with the write permission, and can access the same data resource for the consecutive multiple threads with the read access right, so that the multi-thread accesses the same data resource is satisfied. The security requirements can increase the processing speed of multi-threading and reduce the blocking time of multi-threading.

DRAWINGS

FIG. 1 is a flowchart of a preferred embodiment of a synchronization lock based multi-thread processing method provided by the present invention.

2 is a schematic structural diagram of a preferred embodiment of a terminal provided by the present invention.

Detailed ways

The present invention provides a multi-thread processing method based on a genlock, a terminal, and a storage medium. The present invention will be further described in detail below with reference to the accompanying drawings and embodiments. It is understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

The singular forms "a", "an", "the" It is to be understood that the phrase "comprise" or "an" or "an" Integers, steps, operations, components, components, and/or groups thereof. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element. Further, "connected" or "coupled" as used herein may include either a wireless connection or a wireless coupling. The phrase "and/or" used herein includes all or any one and all combinations of one or more of the associated listed.

Those skilled in the art will appreciate that all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the invention belongs, unless otherwise defined. It should also be understood that terms such as those defined in a general dictionary should be understood to have meaning consistent with the meaning in the context of the prior art, and will not be idealized or excessive unless specifically defined as here. The formal meaning is explained.

The contents of the invention will be further described by the following description of embodiments with reference to the accompanying drawings.

Please refer to FIG. 1. FIG. 1 is a flowchart of a preferred embodiment of a synchronization lock based multi-thread processing method according to the present invention. The multi-thread processing method includes:

S10. When multiple threads access the same data resource, the multiple threads are sorted according to the access time, and the preset synchronization locks are sequentially accessed according to the sorting;

S20. Control, by the synchronization lock, that the thread having the write permission separately accesses the same data resource, and the continuous multi-thread with the read permission simultaneously accesses the same data resource.

The embodiment provides a synchronization lock-based multi-thread processing method, when multiple threads are accessed by the same data resource, the multiple thread case access times are sorted, and the preset synchronization locks are sequentially accessed according to the sorting order; Controlling, by the synchronization lock, the access mode of each thread, for a thread having write permission, accessing when the same data resource is not accessed by other threads; for a thread having read permission, the same data resource is being Read access threads access or access by other threads, that is, multiple consecutive read access threads can access the same data resource at the same time. Since the read access does not modify the same data resource, multiple read access threads access the same data at the same time. Resources do not create data inconsistencies or inaccuracies, and at the same time reduce the thread's waiting time, thus solving the problem of thread blocking.

Specifically, in the step S10, for the data resource with hotspot access, in the object storage system based on the underlying distributed storage engine, the data is initiated by different clients or applications based on the HTTP protocol. The resource access request, that is, the presence of at most access threads (recorded as multi-threaded) for the same data resource, the upper-layer application receives the multi-threaded access to the same data resource. When the upper layer application receives the multithreading of the same data, the threads of the same data resource received by the upper layer application are sorted. In addition, the sorting can be directly ordered on different engine access agents that request data resources from the underlying storage engine, or the access requests on different engine access agents can be routed to an engine access agent for sorting. The embodiment of the present invention preferably routes access requests on different engine access agents to an engine access agent for sorting, so that when the concurrent access requests are sorted, no state query is required between different engine access agents.

Further, in the step S20, the access mode of the thread is controlled by the synchronization lock, in the access mode, for a thread having write permission (a thread that performs modification or write operation on the same data resource) Accessing the same data resource; for a thread having a read permission (a thread that performs a read operation on the same data resource), a plurality of consecutive threads (threads in a consecutive position after sorting) simultaneously access the same data resource. In addition, the concentric lock configures access rights for threads, and controls access of the thread to the same data resource according to the access rights configured for the thread and the access manner corresponding to the access rights, wherein the access rights include read access rights and write access rights. .

Embodiment 1

This embodiment will be described in detail with respect to the synchronization lock control multi-thread access to the same data resource involved in the above embodiment. In addition, in this embodiment, the processing procedure of a thread that needs to acquire read access rights and perform read access to the same data resource is described. Other processing steps of the multi-thread sorting process may refer to the foregoing embodiment, and no longer Narrative

In this embodiment, the controlling, by the synchronization lock, the thread having the write permission to access the same data resource separately, and the consecutive multi-threads having the read permission simultaneously accessing the same data resource may include:

S101. When the first thread accesses the synchronization lock, detecting the access permission that the first thread needs to acquire, where the access permission includes a read access right and a write access right.

Specifically, when the first thread needs to obtain the access authority, the first thread needs the synchronization lock for the configuration, and a read access permission and a write access permission are preset in the synchronization lock. That is, it is detected whether the first thread acquires read access rights or write access rights in the synchronization lock. In addition, the write access permission of the synchronous lock configuration can be acquired by only one thread at a time; the read access right can be acquired by multiple threads at the same time. That is to say, only one thread at each time in the multi-thread accessing the same data resource can have write access rights, that is, two threads cannot have write access at the same time. In a multi-thread that accesses the same data resource, there may be multiple threads having write access rights at the same time.

S102. When the first thread needs to obtain read access permission, detect whether the first thread has write access authority. If yes, execute step S103. If not, perform step 104.

Specifically, after determining that the first thread acquires the read access right, it is detected whether the first thread has write access permission to determine whether the same data resource is accessed by another thread having write permission.

S103. If the first thread has write access rights, configure read access rights for the first thread, and control the first thread to access the same data resource.

Specifically, the first thread has write access permission, and no other thread having write access rights enters the same data resource by using the synchronization lock. At this time, the read access authority is configured for the first thread, and is controlled. The first thread accesses the same data resource.

S104. If the first thread does not have the write access right, detect whether the same data resource is in the access state of the first write access thread. If yes, execute step S108. If not, execute step S105.

Specifically, when the first thread does not have write access rights, it indicates that the same data resource may be accessed by a write access thread having write access rights; thus, it is required to detect whether the same data resource is in the first write access thread. Access status.

S105. If the first write access thread is not in the access state, detect whether there is a second write access thread in the wait state. If yes, execute step S107. If not, execute step S106.

Specifically, the not being accessed by the first write access thread indicates that the same data resource is in an idle state or is accessed by a read access thread. Since the first thread does not have the write access right, the thread may acquire the write access right and wait in the state, so that it is necessary to detect whether there is a second write access thread in the waiting state, so that the first thread can avoid the same data resource. The order of access is different from the order of access to the sync lock, and the second write access thread that is waiting is waiting for a long time, or is always in a wait state, thereby applying the feedback speed of the second write access thread, and even failing to feed back. In addition, this also ensures that multiple read access rights to access the same data resource are continuous in access time, and the symbol synchronization lock is set to access mode.

S106. When the second write access thread does not exist, configure write access rights for the first thread, and control the first thread to access the same data resource.

Specifically, there is no second write access thread, indicating that the same data resource is in an idle state or is accessed by a read access thread, and if the same data resource is accessed by the read access thread, the read access thread accessing the same data resource is The first thread is a continuous thread.

S107. Control the first thread thread to sleep state when there is a second write access thread.

Specifically, when there is a second write access thread, the first thread is not configured to configure read access rights, and at the same time, it is controlled to enter a sleep state.

S108. If it is in the access state of the first write access thread, determine whether the first thread and the first write access thread are the same; if they are the same, execute step S109, and if not, perform 110.

S109. If the same, configure read access rights for the first thread, and control the first thread to access the same data resource, and increase the number of accesses of the first thread by one.

Specifically, the number of accesses of the first thread is recorded, so that the thread is subsequently released according to the number of accesses.

S110. If not, control the first thread to enter a sleep state.

Embodiment 2

In this embodiment, the processing procedure of the thread that needs to acquire the write access right and read access to the same data resource will be described. Other processing steps of the multi-thread sorting process and the processing steps of the read permission may refer to the embodiment as described above. , will not repeat them here.

S201. When the first thread accesses the synchronization lock, detecting the access permission that the first thread needs to obtain, where the access permission includes a read access right and a write access right.

S202, when the first thread needs to obtain the write access right, it is detected whether the same data resource is in an idle state, if it is idle, step S203 is performed, if not idle, step S204 is performed;

S203. When in an idle state, configure write access rights for the first thread, and control the first thread to access the same data resource.

S204, when not in the idle state, determine the type of the second thread accessing the same data resource, if it is a read access thread, step S205 is performed, if the access thread is written, step 206 is performed;

S205. If the type of the second thread is a read access thread, control the first thread to enter a waiting state.

S206, if the type of the second thread is a write access thread, detecting whether the first thread is the same as the second thread; if the same, step S207 is performed, if not, step S208 is performed;

S207. If the same, configure write access rights for the first thread, and control the thread to access the same data resource, and increase the number of accesses of the thread by one;

S208. If not, control the first thread to enter a waiting state.

In this embodiment, it is determined whether the write access right is configured for the first thread according to the access status of the same resource, so as to control the first thread to access the same data resource, so that the write access process can only access the same data resource separately. , to avoid the write or modify of the same data resource due to the write access request, which affects the consistency of the data.

Embodiment 3

In the embodiment, the process of leaving the synchronization lock is described. For the other processing steps of the multi-thread, refer to the foregoing embodiment, and details are not described herein.

The synchronization lock-based multi-thread processing method provided in this embodiment further includes:

S301. Determine, when the third thread accessing the same resource leaves, the access type of the third thread.

S302. If the third thread is a read access thread/write access thread, detecting whether the third thread has read access permission/write access permission, and acquiring the read permission/write access permission when the third thread has read access permission/write access permission. The number of accesses corresponding to the third thread;

S303. When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up.

S304. When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.

The implementation performs the permission detection on the first thread before the third thread leaves the synchronization lock to enter the same data resource, and prompts the abnormality when it does not have the permission corresponding to the access operation to be performed, and has the need to perform the abnormality. When the access operation corresponds to the permission, the corresponding access times are detected. If the number of accesses is greater than 1, the number of accesses is reduced by one. If equal to 1, the third thread is removed from the cache, and the manual performs the current access operation. The third thread can be released.

The present invention also provides a storage medium storing a plurality of instructions adapted to be loaded by a processor and to perform a synchronization lock based multi-thread processing method as described above.

The present invention also provides a terminal, as shown in FIG. 2, which includes at least one processor 20; a display screen 21; and a memory 22, which may further include a communication interface 23 and a bus 24. . Among them, the processor 20, the display screen 21, the memory 22, and the communication interface 23 can complete communication with each other through the bus 24. The display screen 21 is set to display a user guidance interface preset in the initial setting mode. The communication interface 23 can transmit information. The processor 20 can call the logic instructions in the memory 22 to perform the genlock-based multi-thread processing method in the above embodiment.

In addition, the logic instructions in the memory 22 described above may be implemented in the form of software functional units and sold or used as separate products, and may be stored in a computer readable storage medium.

The memory 22 is a computer readable storage medium that can be configured to store a software program, a computer executable program, a program instruction or module corresponding to the genlock-based multi-thread processing method in the embodiment of the present disclosure. The processor 30 executes the function application and the data processing by executing a software program, an instruction or a module stored in the memory 22, that is, the genlock-based multi-thread processing method in the above embodiment is implemented.

The memory 22 may include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application required for at least one function; the storage data area may store data created according to usage of the terminal device, and the like. Further, the memory 22 may include a high speed random access memory, and may also include a nonvolatile memory. For example, a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, etc., may also be used to store a program code. State storage medium.

In addition, the above-described storage medium and the specific processes loaded and executed by the plurality of instruction processors in the terminal have been described in detail in the above-described genlock-based multi-thread processing method, and will not be further described herein.

It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and are not limited thereto; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that The technical solutions described in the foregoing embodiments are modified, or the equivalents of the technical features are replaced. The modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

A synchronization lock based multi-thread processing method, wherein the multi-thread processing method comprises:

When multiple threads access the same data resource, the multiple threads are sorted according to the access time, and the preset synchronization locks are sequentially accessed according to the sorting;

When the first thread accesses the synchronization lock, detecting the access permission that the first thread needs to obtain, wherein the access permission includes a read access right and a write access right;

When the first thread needs to acquire read access rights, detecting whether the first thread has write access rights;

If the first thread has write access rights, configure read access rights for the first thread, and control the first thread to access the same data resource.
The method according to claim 1, wherein the multi-thread processing method further comprises:

If the first thread does not have write access rights, detecting whether the same data resource is in a state accessed by the first write access thread;

If the same data resource is not in the access state by the first write access thread, detecting whether there is a second write access thread in the waiting state;

When the second write access thread does not exist, configuring write access rights for the first thread, and controlling the first thread to access the same data resource;

The first thread thread sleep state is controlled when there is a second write access thread.
The method according to claim 2, wherein the multi-thread processing method further comprises:

If the same data resource is in the access state by the first write access thread, determining whether the first thread is the same as the first write access thread;

If the first thread is the same as the first write access thread, configuring read access rights for the first thread, and controlling the first thread to access the same data resource, and the first thread The number of visits is increased by one;

If the first thread is different from the first write access thread, controlling the first thread to enter a sleep state.
The method according to claim 1, wherein the multi-thread processing method further comprises:

When the first thread needs to obtain write access rights, detecting whether the same data resource is in an idle state;

When the same data resource is in an idle state, configuring write access rights for the first thread and controlling the first thread to access the same data resource.
The method according to claim 4, wherein the multi-thread processing method further comprises:

Determining, when the same data resource is not in an idle state, a type of a second thread accessing the same data resource, where the type includes a read access thread and a write access thread;

If the type of the second thread is a read access thread, the first thread is controlled to enter a wait state.
The method according to claim 5, wherein the multi-thread processing method further comprises:

If the type of the second thread is a write access thread, detecting whether the first thread is the same as the second thread;

If the first thread is the same as the second thread, configure write access rights for the first thread, and control the thread to access the same data resource, and increase the number of accesses of the thread by one;

If the first thread is different from the second thread, controlling the first thread to enter a waiting state.
The multiplex lock processing method according to claim 1, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
The method according to claim 2, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
The method according to claim 3, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
The method according to claim 4, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
The method according to claim 5, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
The multiplex lock processing method according to claim 6, wherein the multi-thread processing method further comprises:

Determining an access type of the third thread when a third thread accessing the same resource leaves;

If the third thread is a read access thread/write access thread, detecting whether the third thread has read access/write access rights, and acquiring the third when it has read access/write access rights The number of accesses corresponding to the thread;

When the number of accesses is 1, the thread is removed from the cache, and the thread in the sleep state is woken up;

When the number of accesses is greater than 1, the number of accesses is decremented by one, and the thread in the dormant state is woken up.
A storage medium, wherein it stores a plurality of instructions adapted to be loaded by a processor and to execute a synchronization lock based multi-thread processing method, the multi-thread processing method comprising:

When multiple threads access the same data resource, the multiple threads are sorted according to the access time, and the preset synchronization locks are sequentially accessed according to the sorting;

Controlling, by the synchronization lock, a thread having a write permission to individually access the same data resource, and a continuous multi-thread having read permission to simultaneously access the same data resource.
The storage medium of claim 13, wherein the controlling, by the synchronization lock, a thread having a write permission to access the same data resource separately, and a continuous multi-thread having a read permission simultaneously accessing the same data resource comprises:

When the first thread accesses the synchronization lock, detecting the access permission that the first thread needs to obtain, wherein the access permission includes a read access right and a write access right;

When the first thread needs to acquire read access rights, detecting whether the first thread has write access rights;

If the first thread has write access rights, configure read access rights for the first thread, and control the first thread to access the same data resource.
The storage medium of claim 14, wherein the controlling, by the synchronization lock, a thread having a write permission to individually access the same data resource, and the plurality of threads having a read permission simultaneously accessing the same data resource further comprises:

If the first thread does not have write access rights, detecting whether the same data resource is in a state accessed by the first write access thread;

If the same data resource is not in the access state by the first write access thread, detecting whether there is a second write access thread in the waiting state;

When the second write access thread does not exist, configuring write access rights for the first thread, and controlling the first thread to access the same data resource;

The first thread thread sleep state is controlled when there is a second write access thread.
The storage medium according to claim 15, wherein said controlling, by said synchronization lock, a thread having a write permission to individually access said same data resource, and said plurality of threads having read permission simultaneously accessing said same data resource further comprises:

If the same data resource is in the access state by the first write access thread, determining whether the first thread is the same as the first write access thread;

If the first thread is the same as the first write access thread, configuring read access rights for the first thread, and controlling the first thread to access the same data resource, and the first thread The number of visits is increased by one;

If the first thread is different from the first write access thread, controlling the first thread to enter a sleep state.
The storage medium of claim 14, wherein the controlling, by the synchronization lock, a thread having a write permission to access the same data resource separately, and a continuous multi-thread having a read permission simultaneously accessing the same data resource further comprises:

When the first thread needs to obtain write access rights, detecting whether the same data resource is in an idle state;

And when the same data resource is in an idle state, configuring write access rights for the first thread, and controlling the first thread to access the same data resource.
The storage medium according to claim 17, wherein said controlling, by said synchronization lock, a thread having a write permission to individually access said same data resource, and said plurality of threads having read permission simultaneously accessing said same data resource further comprises:

Determining, when the same data resource is not in an idle state, a type of a second thread accessing the same data resource, where the type includes a read access thread and a write access thread;

If the type of the second thread is a read access thread, the first thread is controlled to enter a wait state.
The storage medium according to claim 18, wherein said controlling, by said synchronization lock, a thread having a write permission to individually access said same data resource, and said plurality of threads having read permission simultaneously accessing said same data resource further comprises:

If the type of the second thread is a write access thread, detecting whether the first thread is the same as the second thread;

If the first thread is the same as the second thread, configure write access rights for the first thread, and control the thread to access the same data resource, and increase the number of accesses of the thread by one;

If the first thread is different from the second thread, controlling the first thread to enter a waiting state.
A terminal, wherein:

a processor adapted to implement each instruction;

The storage device is adapted to store a plurality of instructions, the instructions being adapted to be loaded by the processor and executing a synchronization lock based multi-thread processing method, the multi-thread processing method comprising:

When multiple threads access the same data resource, the multiple threads are sorted according to the access time, and the preset synchronization locks are sequentially accessed according to the sorting;

Controlling, by the synchronization lock, a thread having a write permission to individually access the same data resource, and a continuous multi-thread having read permission to simultaneously access the same data resource.