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)读写锁适用时机和实例
由于上面的特性,读写锁适合于对数据结构的读次数比写次数多得多的情况。因为, 读模式锁定时可以共享, 以写模式锁住时意味着独占。
实例:
- #include "stdafx.h"
- #include <stdio.h>
- #include <Windows.h>
- #include <process.h>
- #include <time.h>
- long g = 0;
- long temp = 0;
- SRWLOCK g_srw; // 定义读写锁
- CRITICAL_SECTION g_cs; // 定义临界区
- #define THREAD_COUNT 10 // 线程数
- #define ACCESS_TIMES 100000000 // 访问共享变量的次数,增大其值,增加数据竞争发生的可能性
- void __cdecl ThreadProcSRWWrite(void *para)
- {
- printf("sub thread started\n");
- for (int i = 0;i < ACCESS_TIMES;i++)
- {
- AcquireSRWLockExclusive(&g_srw); // 获取写锁
- g = g + 1;
- ReleaseSRWLockExclusive(&g_srw); // 释放写锁
- }
- printf("sub thread finished\n");
- _endthread(); // 可以省略,隐含会调用。
- }
- void __cdecl ThreadProcSRWRead(void *para)
- {
- printf("sub thread started\n");
- for (int i = 0;i < ACCESS_TIMES;i++)
- {
- //AcquireSRWLockExclusive(&g_srw); // 获取写锁
- AcquireSRWLockShared(&g_srw); // 获取读锁
- temp = temp + g - g;
- //ReleaseSRWLockExclusive(&g_srw); // 释放写锁
- ReleaseSRWLockShared(&g_srw); // 释放读锁
- }
- printf("sub thread finished\n");
- _endthread(); // 可以省略,隐含会调用。
- }
- void __cdecl ThreadProcCSWrite(void *para)
- {
- printf("sub thread started\n");
- for (int i = 0;i < ACCESS_TIMES;i++)
- {
- EnterCriticalSection(&g_cs); // 进入临界区
- g = g + 1;
- LeaveCriticalSection(&g_cs); // 退出临界区
- }
- printf("sub thread finished\n");
- _endthread(); // 可以省略,隐含会调用。
- }
- void __cdecl ThreadProcCSRead(void *para)
- {
- printf("sub thread started\n");
- for (int i = 0;i < ACCESS_TIMES;i++)
- {
- EnterCriticalSection(&g_cs); // 进入临界区
- temp = temp + g - g;
- LeaveCriticalSection(&g_cs); // 退出临界区
- }
- printf("sub thread finished\n");
- _endthread(); // 可以省略,隐含会调用。
- }
- int main(int argc, char* argv[])
- {
- clock_t start, end, t1, t2;
- // Testing for SRWLock
- InitializeSRWLock(&g_srw); // 初始化读写锁
- start = clock();
- HANDLE hThread[THREAD_COUNT];
- hThread[0] = (HANDLE)_beginthread(ThreadProcSRWWrite,0,NULL);
- for(int i = 1;i < THREAD_COUNT;i++)
- {
- hThread[i] = (HANDLE)_beginthread(ThreadProcSRWRead,0,NULL);
- }
- for(int i = 0;i < THREAD_COUNT;i++)
- WaitForSingleObject(hThread[i],INFINITE);
- end = clock();
- t1 = end - start;
- // 检查结果
- if (g != ACCESS_TIMES)
- printf("Error Result!\n");
- g = 0;
- // Testing for Critical Section
- InitializeCriticalSection(&g_cs); // 初始化临界区
- start = clock();
- hThread[0] = (HANDLE)_beginthread(ThreadProcCSWrite,0,NULL);
- for(int i = 1;i < THREAD_COUNT;i++)
- {
- hThread[i] = (HANDLE)_beginthread(ThreadProcCSRead,0,NULL);
- }
- for(int i = 0;i < THREAD_COUNT;i++)
- WaitForSingleObject(hThread[i],INFINITE);
- end = clock();
- t2 = end - start;
- DeleteCriticalSection(&g_cs); // 删除临界区
- // 检查结果
- if (g != ACCESS_TIMES*THREAD_COUNT)
- printf("Error Result!\n");
- printf("Timing RW: %ld\n", t1);
- printf("Timing CS: %ld\n", t2);
- printf("Timing CS/RW: %lf\n", t2/(double)t1);
- }
上面这个例子,我创建10个线程,一个线程写,九个线程读。分别使用临界区和读写锁,临界区只是用来作为参考,我想证明一下读写锁对于多读少写的情况下会有一些性能上的提升。所以我希望是使用使用写锁(排他锁)也用来进行读保护,和使用读锁(共享锁)来进行读保护,希望的结果是对于读保护使用读锁效率会有提升。。。结果。。。居然和预料相反!难道读锁不是可以共享?效率不是更高?即上面代码中ThreadProcSRWRead()线程函数注释的部分的比较。先Mark一下,什么时候找到合理的解释了再更新!
欢迎补充!