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

Cand

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

1. typedef struct _SEQUENCE_LOCK   
   
2. {   
   
3.     unsigned int sequence;   
   
4.     HANDLE hLock;   
   
5.    
   
6. }SEQUENCE_LOCK;  

复制代码

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

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. }  

复制代码

自然写锁也需要修改了，

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);   

复制代码

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

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）顺序锁代替不了读写锁，因为读写锁可以保证所有的数据操作，而顺序锁不行

ㄣ负二代

好。。沙发啊。。支持楼主。