CN102999378B - A kind of read-write lock implement method - Google Patents

Abstract

The invention relates to a method for synchronizing threads through a read-write lock. The steps include: 1) initializing the read-write lock, initializing the read critical area and the write critical area to an accessible state, and initializing the write notification event to a triggered state; 2) When multiple reading threads and/or writing threads access shared resources concurrently, protect the key codes in the shared resources according to the critical section, and set the read-write lock; 3) Return the read-write lock information to complete the read-write lock setting and realize resource sharing . The present invention proposes a method for realizing a read-write lock by combining a critical section and an event, which has the characteristics of being simple and easy to use, lightweight and fast. At the same time, the method uses the critical section as the main mutual exclusion tool, avoiding the user state when using the kernel mode object Frequent switching overhead, the writing thread will not wait indefinitely, only need to wait until the reading thread when applying for the writing lock has completed the operation, and will not be preempted by the thread applying for the reading lock later, which greatly improves the performance of the reading and writing lock.

Description

A method for implementing read-write lock

technical field

The invention relates to a read-write lock implementation method, in particular to a synchronization method between threads based on a read-write lock, which can be applied to the technical field of software development of various software system research and development, and belongs to the field of information technology

Background technique

In the field of information technology, software development involves many technologies, including memory data organization and management, message communication, index technology, synchronization and mutual exclusion technology, etc. The present invention focuses on the synchronization technology between threads in software development. In some specific software systems The research and development process involves synchronization technology between threads, and has high real-time and high-efficiency requirements for synchronization operations, such as: real-time database management systems, relational database management systems, middleware, etc.

Existing concurrent synchronous mutex objects (see Microsoft's official explanation materials about mutex objects http://msdn.microsoft.com/en-us/library/windows/desktop/ms684266%28v=vs.85%29 .aspx) mainly includes mutex (Mutex), semaphore (Semaphore), event (Event), critical section (Critical Section) (see Microsoft's official description material about critical section objects http://msdn.microsoft. com/en-us/library/windows/desktop/ms682530%28v=vs.85%29.aspx), etc., can be divided into kernel state objects and user state objects according to the level to which the object belongs, and can also be divided into inter-process synchronization according to the purpose technology and inter-thread synchronization technology. A critical section is a simple way to ensure that only one thread can access data at a certain time. It is a user-mode object; a mutex is similar to a critical section. Only threads with mutex objects have access to resources, but it is more complicated than a critical section. , which belongs to the kernel state object, can realize the safe sharing of resources among different application processes. The semaphore is used to control concurrent access to a resource with a limited number of users, including a usage count, the maximum number of resources, and the current resource count. The maximum number of resources indicates the maximum number of resources that the semaphore can control, and the current number of resources indicates the number of resources currently available to the signal. The number of resources; the event is used to notify the thread that certain events have occurred, thereby waking up the thread to perform subsequent tasks. Mutexes, semaphores, and events are all kernel-mode mutual exclusion or synchronization technologies, so they can also be used for inter-process and thread synchronization. The critical section can only be used for inter-thread synchronization, but because it is a user-mode technology, there is no environment switching overhead from kernel mode to user mode, so its performance is better than mutex.

A large number of concurrent requests in a software system can be divided into read-only requests and read-write requests. The former can operate on shared resources at the same time, while the latter must exclusively occupy shared resources and not allow others to access them. In this case, it is inappropriate to use mutexes, semaphores, events, etc. directly. On the one hand, there is a large switching overhead between the kernel state and the user state, and on the other hand, there is no distinction between concurrent read and write requests, resulting in possible Read-only requests that are executed concurrently become serial executions, greatly reducing system efficiency. Therefore, it is necessary to carefully design an inter-thread synchronization mechanism for a large number of concurrent read and write requests to achieve maximum concurrent execution, thereby improving the overall performance of the software system.

Contents of the invention

The invention designs and proposes a real-time and fast multi-thread synchronization method for accessing shared resources aiming at the real-time requirements and performance requirements of thread synchronization in real-time database management systems, relational database management systems and middleware.

The technical problem to be solved in the present invention

In the process of developing software systems, the problem of concurrent access to shared resources by multiple threads is usually encountered. If the degree of concurrency is relatively low, it can be realized with a simple mutex (Mutex). However, when the degree of concurrency is high, some high-performance software systems also require high performance in synchronous operations among multiple threads. Concurrent multithreading can be divided into two categories according to whether to modify shared resources: read-only threads and modifying threads. A good multi-thread synchronization technology should allow multiple read-only threads to access shared resources at the same time. Secondly, the update thread should wait for the current only After the read thread completes the operation, the shared resource can be obtained immediately, and the subsequent read-only thread will not seize the shared resource from the modifying thread. Since mainstream operating systems such as Windows 2000, WindowsXP, and Windows 2003 Server do not have built-in read-write locks, it usually takes a long time for developers to design and implement read-write locks between threads, and the final effect may not be satisfactory. The high-performance requirements of software systems for synchronization between threads.

Aiming at such technical problems, the present invention proposes a universal, real-time and fast inter-thread read-write lock solution as follows, and provides specific implementation details of the read-write lock. On the one hand, it can greatly reduce the time of developers, on the other hand, it can meet the performance requirements of the software system for synchronization between multiple read and write threads.

A method for implementing a read-write lock, the steps comprising:

1) Initialize the read-write lock, create three objects according to the read-write lock component: read critical area, write critical area and write notification event, the read critical area and the write critical area are initialized to enterable state, and the write notification event Initialized to the triggered state;

2) When multiple reading threads and/or writing threads access the shared resource concurrently, according to the critical section protecting the key code in the shared resource, a read-write lock is set;

2-1) When applying for the read lock interface, first enter the write critical area and then enter the read critical area, prevent the operation of the write or read thread according to the number of read locks, and set the write notification event to a non-triggered state; release the read lock interface , enter the read critical area, and if the number of read locks is 0 at this time, set the write notification event to the trigger state at the same time;

2-2) When applying for the write lock interface, first enter the write critical area and then enter the read critical area, prevent the operation of the write or read thread according to the number of write locks, and set the write notification event to a non-triggered state; release the write lock interface time; enter the read critical area, and simultaneously the write notification event is set to trigger state;

3) Go through the above 2-1) to 2-2) and return the read-write lock information to complete the read-write lock setting and realize resource sharing.

The read-write lock component defines: public member constructor CReadWriteLock and destructor ~CReadWriteLock; application read lock interface function ReadLock and release read lock interface function ReadUnlock; application write lock WriteLock interface function and release write lock interface function WriteUnlock.

The read-write lock component also defines four private members: the maximum number of read locks m_ulMaxReadCount; read critical section m_hReadCriticalSection; write critical section m_hWriteCriticalSection; write notification event m_hWriteNotifyEvent.

The maximum number of read locks m_ulMaxReadCount is 5 by default.

When applying for a write lock in the step 2-2), set a timeout waiting time with a unit of milliseconds, and return failure if the write lock is not obtained after exceeding the waiting time.

Further, in said step 2-1), the operation method of preventing writing or reading threads according to the number of read locks is as follows:

2-1-1) After entering the two critical sections, if it is found that the current number of read locks has reached the maximum number, then return failure, otherwise the current thread can continue to read lock operations;

2-1-2) When the number of current read locks in the step 2-1-1) does not reach the maximum number, the current number of read locks can be increased. If the number of read locks after the increase is greater than 0, the write thread cannot be allowed to perform operate.

Further, in the step 2-2), the method of preventing the operation of writing or reading threads according to the number of write locks is as follows:

2-2-1) First enter the write critical area to prevent other threads from applying for read locks or write locks, and then wait for the write notification event within the set waiting time to ensure that no other threads read or write shared resources;

2-2-2) If the write notification event is not triggered within the set waiting time, the wait times out and returns fail; if the write notification event is triggered within the specified time, it means that there is no reading thread at this time, Obtain an exclusive write lock, and then set the write notification event to a non-triggered state. As long as there is a read lock or write lock, no new write lock application is allowed, and the return is successful;

2-2-3) Step 2-2-2) If the return is successful, the thread applying for the write lock will not leave the write critical area, and when the return fails, the thread applying for the write lock will immediately leave the write critical area.

Furthermore, in the process of releasing the read lock, only enter the read critical area, not the write critical area, and then reduce the number of read locks by 1, and when it is reduced to 0, set the notification event as a trigger state, and exit the read critical area ;

Furthermore, in the process of releasing the write lock, first set the write notification event as a trigger state, and then exit the write critical section.

Furthermore, the read-write lock operates in Windows 2000, Windows XP and Windows 2003 Server without built-in read-write lock.

The read-write lock solution mainly involves three parts. The read-write lock is applied in parallel and processed in parallel: 1) the initialization process of the read-write lock; 2) apply for and release the read lock; 3) apply for and release the write lock. These three parts are all included in the read-write lock class CReadWriteLock realized by the present invention, which is used as a public member function of the class for external use, and two critical area objects are used to protect the key codes of reading and writing respectively, and event objects are used to notify write The state of the lock. Since the speed of the critical section is much faster than that of the mutex, the use of the critical section can obtain higher operating efficiency. Class CReadWriteLock internally uses a variable to record the current number of read locks. When applying and releasing locks, it must judge the relationship with the maximum number of read locks to determine the process of applying for locks.

During the initialization process of the read-write lock, three objects of the read critical area, write critical area and write notification event are created and initialized respectively. The read and write critical areas are initialized to enterable state, and the write notification event is initialized to be triggered state, so that it can accept Write lock application, and then initialize the current number of read locks to 0, that is, read lock applications can also be received.

In the process of applying for a read lock, it is necessary to read and modify the number of current read locks, so a critical section is used to protect this code. The critical section is divided into two, one is a write critical section, which is used to protect operations related to write locks, and the other is a critical section. It is a read critical section, which is used to protect operations related to read locks. Since the write lock is exclusive, you must first enter the write critical section, then enter the read critical section, and the order of exit is reversed, first exit the read critical section, and then exit the write critical section, so as to avoid deadlock Case. After entering the two critical sections, if it is found that the current number of read locks has reached the maximum number, it will return failure, otherwise it means that the current thread can still get read locks, so increase the current number of read locks, if the number of read locks is greater than 0 after the increase , the write thread cannot be allowed to operate. At this time, you can continue to increase the number of read locks, as long as it does not exceed the set maximum number of read locks. When there is a read lock, it is not allowed to apply for a write lock. Therefore, it is also necessary to set the write notification event to a non-triggered state to prevent other threads from obtaining a write lock.

In the process of releasing the read lock, since the number of read locks is greater than 0 at this time, it is impossible for any thread to obtain the write lock, so it is only necessary to enter the read critical section instead of the write critical section, and then reduce the number of read locks by 1, when When it is reduced to 0, it means that there is no thread to read the shared resource at this time, so the thread can be allowed to write, and the waiting writing thread can be woken up by setting the write notification event as the trigger state.

In the process of applying for a write lock, you must first enter the write critical area to prevent other threads from applying for read or write locks, that is, to ensure that they will not be preempted by subsequent threads that apply for read-write locks, and then wait for write notification events to ensure that no other threads are on the shared lock. The resource performs read and write operations. This waiting process can set a timeout period to improve the success rate of applying for a write lock. If the write notification event is not triggered within the specified time, the waiting timeout will return failure. If the write notification event is triggered within the specified time, it means that there is no read thread at this time, the applicant can obtain an exclusive write lock, and then set the write notification event to a non-triggered state, and the return is successful as long as there is a read lock or a write lock. , new write lock applications are not allowed. Return success. If the return is successful, in order to ensure the exclusiveness of the write lock, the thread applying for the write lock will not leave the write critical area, so that other threads applying for the read-write lock will be blocked at the step of entering the write critical area; when the return fails, apply for the write lock The thread will leave the write critical section immediately.

In the process of releasing the write lock, since the write critical area was entered but not exited when the read lock was applied, there is no need to enter the write critical area when the write lock is released, as long as the write notification event is set to the trigger state first, and then Just exit the write critical section.

Beneficial effects of the present invention

According to the above technical solutions, it can be seen that the present invention has the following beneficial effects:

1. The present invention proposes a method for realizing a read-write lock by combining a critical section and an event, which is easy to use, lightweight and fast. The method adopts the critical section as the main mutual exclusion tool, avoids the overhead of frequent switching of the user state when using the kernel state object, and greatly improves the performance of the read-write lock.

2. The present invention optimizes the scenario of a large number of read threads and a small number of write threads as follows: there is no conflict between the read threads and the read threads, and the overhead of applying for a read lock when there is already a read lock is very small; the write thread will not be infinite Waiting, you only need to wait until the reading threads that apply for the write lock complete the operation, and the shared resources will not be preempted by the thread that applies for the read lock later.

3. The present invention provides a read-write lock implementation class, which has a concise call interface for applying for and releasing locks, and can be easily integrated into various software systems.

Description of drawings

Fig. 1 is a flow chart of applying for a read lock in an embodiment of the read-write lock implementation method of the present invention;

Fig. 2 is the flowchart of releasing the read lock in an embodiment of the read-write lock implementation method of the present invention;

Fig. 3 is a flow chart of applying for a write lock in an embodiment of the read-write lock implementation method of the present invention;

Fig. 4 is a flow chart of releasing the write lock in an embodiment of the read-write lock implementation method of the present invention;

Fig. 5 is a schematic flowchart of a method for implementing a read-write lock in the present invention.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention. It should be understood that the described embodiments are only some of the embodiments of the present invention, not all of them. example. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without making creative efforts belong to the protection scope of the present invention.

As shown in Figure 5, it is a flow diagram of the implementation method of the read-write lock of the present invention. The read-write lock solution mainly involves three parts, and the read-write lock performs parallel application and parallel processing: 1) the read-write lock initialization process; 2) application and Release the read lock; 3) apply and release the write lock.

Read-write lock component

The read-write lock class is defined as follows:

[1] class CReadWriteLock{

[2] public:

[3] CReadWriteLock(ULONG ulMaxReadCount=5);

[4] virtual～CReadWriteLock();

[5] virtual BOOL ReadLock();

[6] virtual void ReadUnLock();

[7] virtual BOOL WriteLock(ULONG ulWaitMSTime=INFINITE);

[8] virtual void WriteUnLock();

[9]protected:

[10]ULONG m_ulMaxReadCount;

[11] CRITICAL_SECTION m_hReadCriticalSection;

[12] CRITICAL_SECTION m_hWriteCriticalSection;

[13] HANDLE m_hWriteNotifyEvent;

[14]};

Among them, six public methods are defined: CReadWriteLock and ~CReadWriteLock are constructors and destructors; ReadLock and ReadUnlock are interface functions for applying for and releasing read locks; WriteLock and WriteUnlock are interface functions for applying for and releasing write locks.

In addition, four private members are defined: m_ulMaxReadCount indicates the maximum number of read locks, and the default is 5; m_hReadCriticalSection is the critical section for protecting read operations, that is, read critical section; m_hWriteCriticalSection is the critical section for protecting write operations, that is, write Critical section; m_hWriteNotifyEvent is a write notification event used to indicate the state of the write lock.

Initialize interface method implementation

The constructor of class CReadWriteLock is an initialization interface method, defined as:

CReadWriteLock::CReadWriteLock(ULONG ulMaxReadCount=5);

The parameter ulMaxReadCount is used to set the maximum number of concurrent read locks allowed by the read-write lock, and the default is 5. Generally speaking, the maximum number of concurrent read locks should not be set too large, otherwise performance will be affected.

The specific implementation code of the initialization interface method is as follows:

[1]::InitializeCriticalSection(&m_hReadCriticalSection);

[2]::InitializeCriticalSection(&m_hWriteCriticalSection);

[3] m_hWriteNotifyEvent=::CreateEvent(0,TRUE,TRUE,0);

[4] m_ulReadCount = ulMaxReadCount;

This method mainly initializes the critical area, event and other objects used by the read-write lock to call the system interface, the write notification event is initialized to the trigger state, and the maximum number of concurrent read locks is set at the same time.

As shown in Figure 1 is the flow chart of applying for a read lock in an embodiment of the read-write lock implementation method of the present invention; the return value is set to TRUE earlier, enters the write critical area, and after entering two critical areas, starts to read the number of locks Operate with the write notification event, and then judge that if the number of read locks has reached the maximum number, set the return value to FALSE, otherwise, increase the number of read locks by 1. Then judge whether the number of read locks is 1. If it is, it means that a thread has just applied for a read lock, so other threads should be rejected to apply for a write lock, so reset the write notification event to a non-triggered state; after completing the above operations, leave the critical section; Finally, return the set return value to the caller.

The following is the specific definition of the interface method for applying for a read lock in the implementation of the interface method for applying for a read lock:

BOOL CReadWriteLock::ReadLock();

If the application for the read lock is successful, it returns TRUE; if the application for the read lock fails, it returns FALSE.

The specific implementation code of the interface method for applying for a read lock is as follows:

[1] BOOL bSucc = TRUE;

[2]::EnterCriticalSection(&m_hWriteCriticalSection);

[3]::EnterCriticalSection(&m_hReadCriticalSection);

[4] if(m_ulReadCount>=m_ulMaxReadCount)

[5] bSucc = FALSE;

[6] else {

[7] m_ulReadCount++;

[8] if(m_ulReadCount==1)

[9]::ResetEvent(m_hWriteNotifyEvent);

[10]}

[11]::LeaveCriticalSection(&m_hReadCriticalSection);

[12]::LeaveCriticalSection(&m_hWriteCriticalSection);

[13] return bSucc;

Among them, the first line first sets the return value to TRUE; the second line enters the write critical area, and the third line enters the read critical area; after entering the two critical areas, it starts to operate on the number of read locks and write notification events, and the fourth line If the number of read locks has reached the maximum number, set the return value to FALSE in line 5, otherwise, increase the number of read locks by 1 in line 7, and then determine whether the number of read locks is 1 in line 8, if yes It means that a thread has just applied for a read lock, so other threads should be rejected to apply for a write lock, so reset the write notification event to a non-triggered state on line 9; after completing the above operations, leave the critical section on lines 11 and 12; finally set The set return value is returned to the caller.

Shown in Fig. 2 is the flow chart of releasing the read lock in one embodiment of the implementation method of the read-write lock of the present invention, and the application enters the read critical area; after entering the critical area, the number of read locks is subtracted by 1; then the number of read locks is judged, if If it is equal to 0, it means that there is no read lock at this time. Set the write notification event to the trigger state, so that the thread that is applying for the write lock can obtain the write lock; leave the read critical section.

The following is the specific definition of the release read lock interface method in the implementation of the release read lock interface method:

void CReadWriteLock::ReadUnLock()

The method is relatively simple internally, and no return value is defined.

The specific implementation code of the release read lock interface method is as follows:

[1]::EnterCriticalSection(&m_hReadCriticalSection);

[2] m_ulReadCount--;

[3] if(m_ulReadCount==0)

[4] ::SetEvent(m_hWriteNotifyEvent);

[5]::LeaveCriticalSection(&m_hReadCriticalSection);

Among them, the first line applies to enter the read critical area; after entering the critical area, the second line will reduce the number of read locks by 1; the third line judges the number of read locks, if it is equal to 0, it means that there is no read lock at this time, so in Line 4 sets the write notification event to the triggered state, so that the thread that is applying for the write lock can obtain the write lock; line 5 is to leave the read critical section.

Figure 3 is a flow chart of applying for a write lock in an embodiment of the read-write lock implementation method of the present invention, wherein the application enters the write critical area; after entering the write critical area, wait for the write notification event and set the waiting timeout time, if If the write notification event is triggered within the specified time, it will return successfully. At this time, it will not exit the critical section. This is because the write operation is exclusive, and other threads are not allowed to have write locks at the same time, so other threads that apply for read-write locks are blocked from entering The initial step of writing the critical section; if the write notification event is not triggered within the specified time, it means that the reading thread has not completed all operations during this period, so the writing operation cannot be performed, so exit the writing critical section, so that the subsequent thread Apply for a read-write lock, then return FALSE.

The following is the specific definition of the interface method of applying for a write lock to implement the interface method of applying for a write lock:

BOOL CReadWriteLock::WriteLock(ULONG ulWaitMSTime);

The parameter ulWaitMSTime is the waiting time for applying for a write lock, in milliseconds. If the application fails after this time, it indicates that the application operation has timed out and returns FALSE; if the application is successful within the specified time, it returns TRUE.

The specific implementation code of the interface method for applying for a write lock is as follows:

[1]::EnterCriticalSection(&m_hWriteCriticalSection);

[2] if(WAIT_OBJECT_0==::WaitForSingleObject(m_hWriteNotifyEvent,ulWaitMSTime))

[3] return TRUE;

[4] else {

[5] ::LeaveCriticalSection(&m_hWriteCriticalSection);

[6] return FALSE;

[7]}

Among them, line 1 applies to enter the write critical area; after entering the write critical area, wait for the write notification event in line 2 and set the waiting timeout period. If the write notification event is triggered within the specified time, it will return successfully in line 3. At this time, the critical section is not exited. This is because the write operation is exclusive and other threads are not allowed to own the write lock at the same time. Therefore, other threads applying for the read-write lock are prevented from entering the initial step of writing the critical section; if within the specified time The write notification event is not triggered, which means that the read thread has not completed all operations during this period, so the write operation cannot be performed, so exit the write critical section on line 5 so that subsequent threads can apply for read-write locks, and then Line 6 returns FALSE.

Figure 4 is a flow chart of releasing the write lock in an embodiment of the read-write lock implementation method of the present invention, reset the write notification event to the trigger state, and then exit the critical section protecting the write operation, so that subsequent threads apply for the read-write lock.

The following is the specific definition of the release write lock interface method to implement the release write lock interface method:

void CReadWriteLock::WriteUnLock();

The method is relatively simple internally, and no return value is defined.

The specific code for releasing the write lock interface method is as follows:

[1]::SetEvent(m_hWriteNotifyEvent);

[2]::LeaveCriticalSection(&m_hWriteCriticalSection);

The first line is to reset the write notification event to the triggered state, and then the second line exits the critical section that protects the write operation, so that subsequent threads can apply for read-write locks.

Claims (9)

1. a read-write lock implement method, its step comprises:

1) initialization Read-Write Locks, reads critical section according to Read-Write Locks building component, writes critical section and writes notification event three objects, described in read critical section and described critical section of writing is initialized as and can gets the hang of, described in write notification event and be initialized as the state of being triggered;

2) read thread when multiple and/or write thread Concurrency Access shared resource, read critical section and write critical section to protect key code in described shared resource according to described, Read-Write Locks is set;

When 2-1) applying for read lock interface, be introduced into and write critical section and enter again and read critical section, stop the operation of write or read thread according to read lock number, write notification event simultaneously and be set to non-toggle state; During release read lock interface, enter and read critical section, if read lock number is 0, described notification event of writing is set to trigger state simultaneously;

2-2) application is when writing lock interface, is introduced into write critical section and enter and read critical section, according to the operation writing lock number and stop write or read thread, writes notification event and be set to non-toggle state simultaneously; When lock interface is write in release, enter and read critical section, write notification event simultaneously and be set to trigger state;

3) travel through described 2-1) to 2-2) return Read-Write Locks information complete Read-Write Locks arrange, realize resource sharing.

2. read-write lock implement method as claimed in claim 1, is characterized in that, define in described Read-Write Locks assembly: open member's constructed fuction CReadWriteLock and destructor function ~ CReadWriteLock; Application read lock interface function ReadLock and release read lock interface function ReadUnlock; Lock WriteLock interface function is write in application and lock interface function WriteUnlock is write in release.

3. read-write lock implement method as claimed in claim 1 or 2, is characterized in that, also define four privately owned members in described Read-Write Locks assembly: maximum read lock number m_ulMaxReadCount; Read critical section m_hReadCriticalSection; Write critical section m_hWriteCriticalSection; Write notification event m_hWriteNotifyEvent.

4. read-write lock implement method as claimed in claim 3, it is characterized in that, described maximum read lock number m_ulMaxReadCount is defaulted as 5.

5. read-write lock implement method as claimed in claim 1, is characterized in that, described step 2-2) in application when writing lock, the waiting-timeout time that a unit is Millisecond is set, obtains yet after exceeding the described stand-by period and write lock and namely return failure.

6. read-write lock implement method as claimed in claim 1, is characterized in that, described step 2-1) in, stop the method for operating of write or read thread as follows according to read lock number:

After 2-1-1) entering described two critical sections, if find, current read lock number reaches maximum number, then return failure, otherwise illustrates that current thread can proceed read lock operation;

2-1-2) as described step 2-1-1) in current read lock number do not reach maximum number, current read lock number can be increased, if increase after read lock number be greater than 0, then can not allow to write thread and operate.

7. read-write lock implement method as claimed in claim 1, is characterized in that, described step 2-2) in, stop the method for the operation of write or read thread as follows according to writing lock number:

2-2-1) be introduced into and write critical section and stop other thread application read lock or write lock, then within the stand-by period of setting etc. notification event to be written to guarantee not having other thread to carry out read-write operation to shared resource;

If 2-2-2) write notification event within the stand-by period of described setting not to be triggered, then wait timeout, returns failure; If write notification event to be at the appointed time triggered, then illustrate and now do not read thread, what acquisition was exclusive writes lock, then will write notification event and be set to non-toggle state, and be latched in as long as have read lock or write, and does not just allow new writing to lock application, returns successfully;

2-2-3) described step 2-2-2) if return successfully, application is write locking wire journey and can not be left and write critical section, when returning failure, the thread that lock is write in application will leave at once writes critical section.

8. read-write lock implement method as claimed in claim 1, is characterized in that,

In described release read lock process, only enter and read critical section, do not enter and write critical section, then read lock number is subtracted 1, when reducing to 0, notification event being set to trigger state, exiting and reading critical section;

Described release is write in lock process, first will write notification event and be set to trigger state, then exits and write critical section.

9. read-write lock implement method as claimed in claim 1, it is characterized in that, described Read-Write Locks does not have to operate in the operating system of built-in Read-Write Locks in Windows 2000, WindowsXP and Windows 2003Server.