多线程的那点儿事（之顺序锁） 读写锁的升级

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

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

[cpp]  view plain copy

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

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

[cpp]  view plain copy

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 plain copy

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 plain copy

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