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

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

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

[cpp] view plaincopyprint?

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

HANDLE hLock;void sub_func(){    /*...*/    WaitForSingleObject(hLock, INFINITE);    do_something();    ReleaseMutex(hLock);    /*...*/}void data_process(){    /*...*/        WaitForSingleObject(hLock, INFINITE);    sub_func();    ReleaseMutex(hLock);    /*...*/}

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

    （1）嵌套锁的数据结构

[cpp] view plaincopyprint?

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

typedef struct _NestLock{    int threadId;    int count;    HANDLE hLock;}NestLock;NestLock* create_nest_lock(HANLDE hLock){    NestLock* hNestLock = (NestLock*)malloc(sizeof(NestLock));    assert(NULL != hNestLock);    hNestLock->threadId = hNestLock->count = 0;    hNestLock->hLock = hLock;    return hNestLock;}

    （2）申请嵌套锁

[cpp] view plaincopyprint?

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

void get_nest_lock(NestLock* hNestLock){    assert(NULL != hNestLock);    if(hNestLock->threadId == GetThreadId())    {        hNestLock->count ++;    }else{        WaitForSingleObject(hNestLock->hLock);        hNestLock->count = 1;        hNestLock->threadId = GetThreadId();    }}

    （3）释放锁

[cpp] view plaincopyprint?

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

void release_nest_lock(NestLock* hNestLock){    assert(NULL != hNestLock);    assert(GetThreadId() == hNestLock->threadId);    hNestLock->count --;    if(0 == hNestLock->count){        hNestLock->threadId = 0;        ReleaseMutex(hNestLock->hLock);    }}

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