转载 多线程的那点儿事（之嵌套锁）

Cand

嵌套锁这个概念，主要是为了根据编程中的一种情形引申出来的。什么情况呢，我们可以具体说明一下。假设你在处理一个公共函数的时候，因为中间涉及公共数据，所以你加了一个锁。但是，有一点比较悲哀。这个公共函数自身也加了一个锁，而且和你加的锁是一样的。所以，除非你的使用的是信号量，要不然你的程序一辈子也获取不了这个锁。

1. [cpp] view plaincopyprint?HANDLE hLock;   
   
2.    
   
3. void sub_func()   
   
4. {   
   
5.     /*...*/   
   
6.     WaitForSingleObject(hLock, INFINITE);   
   
7.     do_something();   
   
8.     ReleaseMutex(hLock);   
   
9.     /*...*/   
   
10. }   
    
11.    
    
12. void data_process()   
    
13. {   
    
14.     /*...*/      
    
15.     WaitForSingleObject(hLock, INFINITE);   
    
16.     sub_func();   
    
17.     ReleaseMutex(hLock);   
    
18.     /*...*/   
    
19. }  
    

复制代码

出现这种情况的原因很多。很重要的一个方面是因为软件的各个模块是不同的人负责的。所以本质上说，我们根本无法确定别人使用了什么样的锁。你也无权不让别人使用某个锁。所以，遇到这种情况，只好靠你自己了。嵌套锁就是不错的一个解决办法。

    （1）嵌套锁的数据结构

1. print?typedef struct _NestLock   
   
2. {   
   
3.     int threadId;   
   
4.     int count;   
   
5.     HANDLE hLock;   
   
6. }NestLock;   
   
7.    
   
8. NestLock* create_nest_lock(HANLDE hLock)   
   
9. {   
   
10.     NestLock* hNestLock = (NestLock*)malloc(sizeof(NestLock));   
    
11.     assert(NULL != hNestLock);   
    
12.    
    
13.     hNestLock->threadId = hNestLock->count = 0;   
    
14.     hNestLock->hLock = hLock;   
    
15.     return hNestLock;   
    
16. }  
    

复制代码

（2）申请嵌套锁

1. void get_nest_lock(NestLock* hNestLock)   
   
2. {   
   
3.     assert(NULL != hNestLock);   
   
4.    
   
5.     if(hNestLock->threadId == GetThreadId())   
   
6.     {   
   
7.         hNestLock->count ++;   
   
8.     }else{   
   
9.         WaitForSingleObject(hNestLock->hLock);   
   
10.         hNestLock->count = 1;   
    
11.         hNestLock->threadId = GetThreadId();   
    
12.     }   
    
13. }  
    

复制代码

（3）释放锁

1. print?void release_nest_lock(NestLock* hNestLock)   
   
2. {   
   
3.     assert(NULL != hNestLock);   
   
4.     assert(GetThreadId() == hNestLock->threadId);   
   
5.    
   
6.     hNestLock->count --;   
   
7.     if(0 == hNestLock->count){   
   
8.         hNestLock->threadId = 0;   
   
9.         ReleaseMutex(hNestLock->hLock);   
   
10.     }   
    
11. }  

复制代码

文章总结：
    （1）嵌套锁与其说是新的锁类型，不如说是统计锁而已
    （2）嵌套锁和普通的锁一样，使用十分方便
    （3）嵌套锁也有缺点，它给我们的锁检测带来了麻烦

ㄣ负二代

我来抢了你的沙发。。嘿。
必须支持！

萧杨

能不能翻译一下啊