读写锁的特性

 

读写锁的特性

分类： 多线程-Windows 2011-11-09 21:01  406人阅读  评论(0)  收藏  举报

thread access testing null windows 数据结构

Summary:

分析读写锁的特性，代码以Windows为例。但是其实读写锁最先是Linux里面有的，所以说，下面的分析，适用于Linux和Windows平台。

Wiki：http://en.wikipedia.org/wiki/Readers-writer_lock

百度百科：http://baike.baidu.com/view/2214179.htm

（1）读写锁

读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言，能提高并发性，因为在多处理器系统中，它允许同时有多个读者来访问共享资源，最大可能的读者数为实际的逻辑CPU数。写者是排他性的，一个读写锁同时只能有一个写者或多个读者（与CPU数相关），但不能同时既有读者又有写者。

在读写锁保持期间也是抢占失效的。

基本功能特点：

如果读写锁当前没有读者，也没有写者，那么写者可以立刻获得读写锁，否则它必须自旋在那里，直到没有任何写者或读者。如果读写锁没有写者，那么读者可以立即获得该读写锁，否则读者必须自旋在那里，直到写者释放该读写锁。

具体分情况来说，一个读写锁的状态有：

A, 没有读者，没有写者：写者可以获得锁，读者可以获得锁；

B,    有读者，没有写着：写着不能获得锁，读者可以获得锁；

C,    没有读者，有写着：写着不能获得锁，读者可以获得锁。

D,        有读者，有写着：不可能！

总之，只要没有写着，那么读者就可以获得锁。必须没有读者并且没有写着，写者才能获得锁。正因为如此，读写锁也成为“共享排他锁(共享独占锁)”，“多读锁”或者“单写多读锁"。个人觉得，单写多读锁，这个名称最能反应其特性，也更容易记住。

（2）读写锁的特性

上面的特性，总结为一句话就是：一次只有一个线程可以占有写模式的读写锁, 但是可以有多个线程同时占有读模式的读写锁。

（3）读写锁适用时机和实例

由于上面的特性，读写锁适合于对数据结构的读次数比写次数多得多的情况。因为， 读模式锁定时可以共享, 以写模式锁住时意味着独占。

实例：

1. #include "stdafx.h"    
2. #include <stdio.h>    
3. #include <Windows.h>    
4. #include <process.h>  
5. #include <time.h>  
6.   
7. long g = 0;   
8. long temp = 0;  
9.   
10. SRWLOCK g_srw;      // 定义读写锁    
11. CRITICAL_SECTION g_cs;      // 定义临界区    
12.   
13. #define THREAD_COUNT        10              // 线程数    
14. #define ACCESS_TIMES        100000000        // 访问共享变量的次数，增大其值，增加数据竞争发生的可能性    
15. void __cdecl ThreadProcSRWWrite(void *para)    
16. {    
17.     printf("sub thread started\n");    
18.     for (int i = 0;i < ACCESS_TIMES;i++)    
19.     {    
20.         AcquireSRWLockExclusive(&g_srw);    // 获取写锁    
21.         g = g + 1;    
22.         ReleaseSRWLockExclusive(&g_srw);    // 释放写锁    
23.     }    
24.     printf("sub thread finished\n");    
25.     _endthread();   // 可以省略，隐含会调用。    
26. }  
27. void __cdecl ThreadProcSRWRead(void *para)    
28. {    
29.     printf("sub thread started\n");    
30.     for (int i = 0;i < ACCESS_TIMES;i++)    
31.     {    
32.         //AcquireSRWLockExclusive(&g_srw);    // 获取写锁  
33.         AcquireSRWLockShared(&g_srw);    // 获取读锁    
34.         temp =  temp + g - g;  
35.         //ReleaseSRWLockExclusive(&g_srw);    // 释放写锁    
36.         ReleaseSRWLockShared(&g_srw);    // 释放读锁    
37.     }    
38.     printf("sub thread finished\n");    
39.     _endthread();   // 可以省略，隐含会调用。    
40. }  
41.   
42. void __cdecl ThreadProcCSWrite(void *para)    
43. {    
44.     printf("sub thread started\n");    
45.     for (int i = 0;i < ACCESS_TIMES;i++)    
46.     {    
47.         EnterCriticalSection(&g_cs);    // 进入临界区    
48.         g = g + 1;    
49.         LeaveCriticalSection(&g_cs);    // 退出临界区    
50.     }    
51.     printf("sub thread finished\n");    
52.     _endthread();   // 可以省略，隐含会调用。    
53. }   
54.   
55. void __cdecl ThreadProcCSRead(void *para)    
56. {    
57.     printf("sub thread started\n");    
58.     for (int i = 0;i < ACCESS_TIMES;i++)    
59.     {    
60.         EnterCriticalSection(&g_cs);    // 进入临界区    
61.         temp =  temp + g - g;  
62.         LeaveCriticalSection(&g_cs);    // 退出临界区    
63.     }    
64.     printf("sub thread finished\n");    
65.     _endthread();   // 可以省略，隐含会调用。    
66. }   
67.   
68. int main(int argc, char* argv[])    
69. {    
70.     clock_t start, end, t1, t2;  
71.   
72.     // Testing for SRWLock  
73.     InitializeSRWLock(&g_srw);  // 初始化读写锁    
74.     start = clock();  
75.     HANDLE hThread[THREAD_COUNT];  
76.     hThread[0] = (HANDLE)_beginthread(ThreadProcSRWWrite,0,NULL);  
77.     for(int i = 1;i < THREAD_COUNT;i++)  
78.     {  
79.         hThread[i] = (HANDLE)_beginthread(ThreadProcSRWRead,0,NULL);  
80.     }  
81.   
82.     for(int i = 0;i < THREAD_COUNT;i++)    
83.         WaitForSingleObject(hThread[i],INFINITE);    
84.     end = clock();  
85.     t1 = end - start;  
86.     // 检查结果    
87.     if (g != ACCESS_TIMES)       
88.         printf("Error Result!\n");    
89.   
90.     g = 0;  
91.     // Testing for Critical Section  
92.     InitializeCriticalSection(&g_cs);   // 初始化临界区    
93.     start = clock();  
94.     hThread[0] = (HANDLE)_beginthread(ThreadProcCSWrite,0,NULL);  
95.     for(int i = 1;i < THREAD_COUNT;i++)  
96.     {  
97.         hThread[i] = (HANDLE)_beginthread(ThreadProcCSRead,0,NULL);  
98.     }   
99.   
100.     for(int i = 0;i < THREAD_COUNT;i++)    
101.         WaitForSingleObject(hThread[i],INFINITE);    
102.     end = clock();  
103.     t2 = end - start;  
104.     DeleteCriticalSection(&g_cs);   // 删除临界区    
105.   
106.     // 检查结果    
107.     if (g != ACCESS_TIMES*THREAD_COUNT)    
108.         printf("Error Result!\n");    
109.   
110.     printf("Timing RW: %ld\n", t1);  
111.     printf("Timing CS: %ld\n", t2);  
112.     printf("Timing CS/RW: %lf\n", t2/(double)t1);  
113. }  

上面这个例子，我创建10个线程，一个线程写，九个线程读。分别使用临界区和读写锁，临界区只是用来作为参考，我想证明一下读写锁对于多读少写的情况下会有一些性能上的提升。所以我希望是使用使用写锁（排他锁）也用来进行读保护，和使用读锁（共享锁）来进行读保护，希望的结果是对于读保护使用读锁效率会有提升。。。结果。。。居然和预料相反！难道读锁不是可以共享？效率不是更高？即上面代码中ThreadProcSRWRead()线程函数注释的部分的比较。先Mark一下，什么时候找到合理的解释了再更新！

欢迎补充！