Slim读写锁

Slim读写锁简称SRWLock，它的目的和临界区相同，对一个资源进行保护，不让其他线程访问。但是不同的是SRWLock允许我们区分哪些线程是读取共享资源的值，哪些线程是修改共享资源的值。所有读线程在同一时刻可以访问共享资源，因为这些线程不会破坏共享资源，只有当写线程要访问共享资源时，才需要进行同步。写线程应当独占式访问资源，其他任何线程都不允许访问资源。这就是SRWLock提供的全部功能。

所以SRWLock的访问分为两种方式：

• 独占式访问：写线程访问共享资源的方式；
• 共享式访问：读线程访问共享资源的方式；

SRWLock需要通过一个SRWLOCK结构来进行实现；

要说明的是SRWLock的使用要求OS至少是Vista，在XP上不能使用。

读写锁对象使用要调用的函数接口如下：

（1）InitializeSRWLock()

[cpp]  view plain  copy

1. VOID WINAPI InitializeSRWLock(  
2.   _Out_  PSRWLOCK SRWLock  
3. );  
4.   
5. //SRWLock：指向读写锁对象的指针；  

在使用读写锁之前要先分配一个SRWLOCK结构，然后调用InitializeSRWLock函数进行读写锁结构的初始化。

（2）AcquireSRWLockExclusive()

[cpp]  view plain  copy

1. VOID WINAPI AcquireSRWLockExclusive(  
2.   _Inout_  PSRWLOCK SRWLock  
3. );  
4.   
5. //SRWLock：指向读写锁对象的指针；  

该函数是写线程独占式的获得对资源的访问权限。

SRWLock初始化完成后，写入在线程可以调用该函数独占式的访问共享资源。

（3）ReleaseSRWLockExclusive()

[cpp]  view plain  copy

1. VOID WINAPI ReleaseSRWLockExclusive(  
2.   _Inout_  PSRWLOCK SRWLock  
3. );  
4.   
5. //SRWLock：指向读写锁对象的指针；  

该函数是写线程释放共享资源。

写入线程在完成对共享资源的更新后，应该调用该函数解除对该共享资源的锁定。

（4）AcquireSRWLockShared()

[cpp]  view plain  copy

1. VOID WINAPI AcquireSRWLockShared(  
2.   _Inout_  PSRWLOCK SRWLock  
3. );  
4.   
5. //SRWLock：指向读写锁对象的指针；  

该函数是读线程共享式访问共享资源。多个读线程可以在同一时刻共享式的访问共享数据资源，这有效的提高的程序的性能。

（5）ReleaseSRWLockShared()

[cpp]  view plain  copy

1. VOID WINAPI ReleaseSRWLockShared(  
2.   _Inout_  PSRWLOCK SRWLock  
3. );  
4.   
5. //SRWLock：指向读写锁对象的指针；  

该函数是读线程释放对共享资源的共享占用。

下面是读写锁的测试代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <windows.h>  
3. #include <process.h>  
4.   
5. using namespace  std;  
6.   
7. SRWLOCK srwTest;  
8. volatile int flag = 0;  
9.   
10. void ReadThread1(void *ptr)  
11. {  
12.     AcquireSRWLockShared(&srwTest);  
13.   
14.     for (int i = 0; i < 5; ++i)  
15.     {  
16.         Sleep(1000);  
17.         cout<<"read thread 1: "<<flag<<endl;  
18.     }  
19.   
20.     ReleaseSRWLockShared(&srwTest);  
21. }  
22.   
23. void ReadThread2(void *ptr)  
24. {  
25.     AcquireSRWLockShared(&srwTest);  
26.   
27.     for (int i = 0; i < 5; ++i)  
28.     {  
29.         Sleep(1000);  
30.         cout<<"read thread 2: "<<flag<<endl;  
31.     }  
32.   
33.     ReleaseSRWLockShared(&srwTest);  
34. }  
35.   
36. void ReadThread3(void *ptr)  
37. {  
38.     AcquireSRWLockShared(&srwTest);  
39.   
40.     for (int i = 0; i < 5; ++i)  
41.     {  
42.         Sleep(1000);  
43.         cout<<"read thread 3: "<<flag<<endl;  
44.     }  
45.   
46.     ReleaseSRWLockShared(&srwTest);  
47. }  
48.   
49. void WriteThread1(void *ptr)  
50. {  
51.     AcquireSRWLockExclusive(&srwTest);  
52.   
53.     flag = 1;  
54.     for (int i = 0; i < 5; ++i)  
55.     {  
56.         Sleep(1000);  
57.         cout<<"write thread 1: "<<flag<<endl;  
58.     }  
59.   
60.     ReleaseSRWLockExclusive(&srwTest);  
61. }  
62.   
63. void WriteThread2(void *ptr)  
64. {  
65.     AcquireSRWLockExclusive(&srwTest);  
66.   
67.     flag = 2;  
68.     for (int i = 0; i < 5; ++i)  
69.     {  
70.         Sleep(1000);  
71.         cout<<"write thread 2: "<<flag<<endl;  
72.     }  
73.   
74.     ReleaseSRWLockExclusive(&srwTest);  
75. }  
76.   
77. int main()  
78. {  
79.     InitializeSRWLock(&srwTest);  
80.   
81.     _beginthread(ReadThread1, 0, NULL);  
82.     _beginthread(ReadThread2, 0, NULL);  
83.     _beginthread(WriteThread1, 0, NULL);  
84.     _beginthread(WriteThread2, 0, NULL);  
85.     _beginthread(ReadThread3, 0, NULL);  
86.       
87.     Sleep(INFINITE);  
88.   
89. }  

程序的运行结果如下：

[cpp]  view plain  copy

1. read thread 2: 0  
2. read thread 1: 0  
3. read thread 2: 0  
4. read thread 1: 0  
5. read thread 2: 0  
6. read thread 1: 0  
7. read thread 2: 0  
8. read thread 1: 0  
9. read thread 2: 0  
10. read thread 1: 0  
11. write thread 1: 1  
12. write thread 1: 1  
13. write thread 1: 1  
14. write thread 1: 1  
15. write thread 1: 1  
16. write thread 2: 2  
17. write thread 2: 2  
18. write thread 2: 2  
19. write thread 2: 2  
20. write thread 2: 2  
21. read thread 3: 2  
22. read thread 3: 2  
23. read thread 3: 2  
24. read thread 3: 2  
25. read thread 3: 2  

从结果可以看出ReadThread1和ReadThread2两个读线程可以同时访问共享资源，然后WriteThread1和WriteThread2请求独占式访问共享资源，但由于有读线程在访问共享资源，所以，这两个写线程会被挂起，直到所有的读线程结束访问。这里有个问题就是：如果写线程被阻塞期间不断的有读线程请求共享式访问共享资源，到底该不该予以访问权限呢，通过上面的代码ReadThread3测试可知，系统不会授予访问权限，因为这样会出现读线程优先，导致写线程一直处于阻塞的不公平状况。