转载 多线程的那点儿事（之读写锁）

Cand

在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？
    有，那就是读写锁。

    （1）首先，我们定义一下基本的数据结构。

1. [cpp] view plaincopyprint?typedef struct _RWLock   
   
2. {   
   
3.     int count;   
   
4.     int state;   
   
5.     HANDLE hRead;   
   
6.     HANDLE hWrite;   
   
7. }RWLock;     
   

复制代码

同时，为了判断当前的锁是处于读状态，还是写状态，我们要定义一个枚举量，

1. [cpp] view plaincopyprint?typedef enum   
   
2. {   
   
3.     STATE_EMPTY = 0,   
   
4.     STATE_READ,   
   
5.     STATE_WRITE   
   
6. };  
   

复制代码

（2）初始化数据结构

1. RWLock* create_read_write_lock(HANDLE hRead, HANDLE hWrite)   
   
2. {   
   
3.     RWLock* pRwLock = NULL;   
   
4.    
   
5.     assert(NULL != hRead && NULL != hWrite);   
   
6.     pRwLock = (RWLock*)malloc(sizeof(RWLock));   
   
7.      
   
8.     pRwLock->hRead = hRead;   
   
9.     pRwLock->hWrite = hWrite;   
   
10.     pRwLock->count = 0;   
    
11.     pRwLock->state = STATE_EMPTY;   
    
12.     return pRwLock;   
    

复制代码

（3）获取读锁

1. void read_lock(RWLock* pRwLock)   
   
2. {   
   
3.     assert(NULL != pRwLock);   
   
4.       
   
5.     WaitForSingleObject(pRwLock->hRead, INFINITE);   
   
6.     pRwLock->counnt ++;   
   
7.     if(1 == pRwLock->count){   
   
8.         WaitForSingleObject(pRwLock->hWrite, INFINITE);   
   
9.         pRwLock->state = STATE_READ;   
   
10.     }   
    
11.     ReleaseMutex(pRwLock->hRead);   
    
12. }  

复制代码

（4）获取写锁

1. void write_lock(RWLock* pRwLock)   
   
2. {   
   
3.     assert(NULL != pRwLock);   
   
4.    
   
5.     WaitForSingleObject(pRwLock->hWrite, INFINITE);   
   
6.     pRwLock->state = STATE_WRITE;   
   
7. }  
   

复制代码

（5）释放读写锁

1. print?void read_write_unlock(RWLock* pRwLock)   
   
2. {   
   
3.     assert(NULL != pRwLock);   
   
4.    
   
5.     if(STATE_READ == pRwLock->state){   
   
6.         WaitForSingleObject(pRwLock->hRead, INFINITE);   
   
7.         pRwLock->count --;   
   
8.         if(0 == pRwLock->count){   
   
9.             pRwLock->state = STATE_EMPTY;   
   
10.             ReleaseMutex(pRwLock->hWrite);   
    
11.         }   
    
12.         ReleaseMutex(pRwLock->hRead);   
    
13.     }else{   
    
14.         pRwLock->state = STATE_EMPTY;   
    
15.         ReleaseMutex(pRwLock->hWrite);   
    
16.     }   
    
17.       
    
18.     return;   

复制代码

文章总结：
    （1）读写锁的优势只有在多读少写、代码段运行时间长这两个条件下才会效率达到最大化；
    （2）任何公共数据的修改都必须在锁里面完成；
    （3）读写锁有自己的应用场所，选择合适的应用环境十分重要；
    （4）编写读写锁很容易出错，朋友们应该多加练习；
    （5）读锁和写锁一定要分开使用，否则达不到效果。

ㄣ负二代

嘿。我来支持你。

必须的。
精易C#有你更精彩