多线程的那点儿事15（之顺序锁）

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


    在互斥数据访问中有一种多读少写的情况。正对这么一种情形，我们也提出了读写锁的方案。但是呢，这个锁有些缺陷。什么缺陷呢？那就是，这个写锁需要在所有的读锁完成之后才能写。否则的话，写锁需要这么一直等下去。

    那么，有没有什么办法能使得写操作快速一点进行呢？那就是顺序锁。

[cpp] view plaincopy
  1. typedef struct _SEQUENCE_LOCK  
  2. {  
  3.     unsigned int sequence;  
  4.     HANDLE hLock;  
  5.   
  6. }SEQUENCE_LOCK;  

    有了这么一个数据结构之后。那么读锁怎么开始呢，

[cpp] view plaincopy
  1. unsigned int get_lock_begin(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     assert(NULL != hSeqLock);  
  4.   
  5.     return hSeqLock->sequence;      
  6. }     
  7.    
  8. int get_lock_retry(SEQUENCE_LOCK* hSeqLock, unsigned int value)  
  9. {  
  10.     unsigned int new_value;  
  11.     assert(NULL != hSeqLock);  
  12.   
  13.     new_value = hSeqLock->sequence;  
  14.     return (new_value & 0x1) || (new_value ^ value);      
  15. }  

    自然写锁也需要修改了，

[cpp] view plaincopy
  1. void get_write_lock(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     assert(NULL != hSeqLock);  
  4.   
  5.     WaitForSingleObject(hSeqLock->hLock);  
  6.     hSeqLock->sequence ++;  
  7. }   
  8.   
  9. void release_write_lock(SEQUENCE_LOCK* hSeqLock)  
  10. {  
  11.     assert(NULL != hSeqLock);  
  12.   
  13.     hSeqLock->sequence ++;  
  14.     ReleaseMutex(hSeqLock->hLock);  
  15. }  

    如果应用呢，其实也不难，

[cpp] view plaincopy
  1. void read_process(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     unsigned int sequence;  
  4.   
  5.     do{  
  6.        sequence = get_lock_begin(hSeqLock);  
  7.        /* read operation  */  
  8.     }while(get_lock_retry(hSeqLock, sequence));  
  9. }  
  10.   
  11. void write_process(SEQUENCCE_LOCK* hSeqLock)  
  12. {  
  13.     get_write_lock(hSeqLock);  
  14.     /* write operation */  
  15.     release_write_lock(hSeqLock);  
  16. }  


总结：
    （1）读锁退出有两个条件，要么写操作正在进行呢，要么没有写锁

    （2）写锁之间需要互斥操作

    （3）互斥操作的数据不能是指针，否则有可能在访问的时候会造成异常，因为有可能边写边读

    （4）顺序锁代替不了读写锁，因为读写锁可以保证所有的数据操作，而顺序锁不行

posted @ 2012-01-17 09:39  董雨  阅读(218)  评论(0)  编辑  收藏  举报