读写锁的特性
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一下，什么时候找到合理的解释了再更新！
欢迎补充！