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

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

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

[cpp] ​​view plain​​​​copy​​

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

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

[cpp] ​​view plain​​​​copy​​

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

自然写锁也需要修改了，

[cpp] ​​view plain​​​​copy​​

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

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

[cpp] ​​view plain​​​​copy​​

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

总结：

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

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

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

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