关闭

多线程---读写锁

419人阅读 评论(0) 收藏 举报


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

    (1)首先,我们定义一下基本的数据结构。

  1. typedef struct _RWLock  
  2. {  
  3.     int count;  
  4.     int state;  
  5.     HANDLE hRead;  
  6.     HANDLE hWrite;  
  7. }RWLock;     
    同时,为了判断当前的锁是处于读状态,还是写状态,我们要定义一个枚举量,
  1. 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;  
  13. }  
    (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. 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;  
  19. }  

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

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:921189次
    • 积分:8028
    • 等级:
    • 排名:第2545名
    • 原创:17篇
    • 转载:350篇
    • 译文:1篇
    • 评论:39条