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

最新推荐文章于 2024-05-30 00:31:36 发布

sir_zeng

最新推荐文章于 2024-05-30 00:31:36 发布

阅读量411

点赞数

分类专栏： linux 多线程

linux 多线程专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了嵌套锁的概念及其在编程中遇到的挑战，详细介绍了嵌套锁的数据结构、申请与释放机制，并指出其作为统计锁而非新锁类型的特点。通过实例演示了如何使用嵌套锁解决公共函数间互斥访问的问题，强调了其在不同开发者协作场景下的实用性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

[cpp] view plain copy print ?

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

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

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

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

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

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

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

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）嵌套锁也有缺点，它给我们的锁检测带来了麻烦