【C++多线程】嵌套锁/递归锁std::recursive_mutex和Windows临界区

Windows临界区

 

　　Windows临界区，同一个线程是可以重复进入的，但是进入的次数与离开的次数必须相等。C++互斥量则不允许同一个线程重复加锁。windows临界区是在windows编程中的内容，了解一下即可，效果几乎可以等同于c++11的mutex。包含#include <windows.h>。windows中的临界区同mutex一样，可以保护一个代码段。但windows的临界区可以进入多次，离开多次，但是进入的次数与离开的次数必须相等，不会引起程序报异常出错。

　　CRITICAL_SECTION对应std::mutex， EnterCriticalSection()对应lock()，LeaveCriticalSection()对应unlock()。

#include <iostream>
#include <thread>
#include <list>
#include <mutex>
#include <Windows.h>

#define __WINDOWSJQ_

using namespace std;

class A
{
public:
    // 把收到的消息传入队列
    void inMsgRecvQueue()
    {
        for (size_t i = 0; i < 1000; ++i)
        {
            cout << "收到消息，并放入队列 " << i << endl;

#ifdef  __WINDOWSJQ_
            EnterCriticalSection(&my_winsec);    //    进入临界区
            //EnterCriticalSection(&my_winsec);    //    可以再次进入临界区,程序不会出错
            msgRecvQueue.push_back(i);
            LeaveCriticalSection(&my_winsec);    //    离开临界区
            //LeaveCriticalSection(&my_winsec);    //    如果进入两次，必须离开两次不会报错
#elif
            my_mutex.lock();
            msgRecvQueue.push_back(i);
            my_mutex.unlock();
#endif //  __WINDOWSJQ_
        }

        cout << "消息入队结束" << endl;
    }

    // 从队列中取出消息
    void outMsgRecvQueue()
    {
        for (size_t i = 0; i < 1000; ++i)
        {
#ifdef  __WINDOWSJQ_
            EnterCriticalSection(&my_winsec);    //    进入临界区
            if (!msgRecvQueue.empty())
            {
                // 队列不为空
                int num = msgRecvQueue.front();
                cout << "从消息队列中取出 " << num << endl;
                msgRecvQueue.pop_front();
            }
            else
            {
                // 消息队列为空
                cout << "消息队列为空 " << endl;
            }
            LeaveCriticalSection(&my_winsec);    //    离开临界区
#elif
            my_mutex.lock();
            if (!msgRecvQueue.empty())
            {
                // 队列不为空
                int num = msgRecvQueue.front();
                cout << "从消息队列中取出 " << num << endl;
                msgRecvQueue.pop_front();
                my_mutex.unlock();
            }
            else
            {
                // 消息队列为空
                cout << "消息队列为空 " << endl;
                my_mutex.unlock();
            }
#endif //  __WINDOWSJQ_
        }

        cout << "消息出队结束" << endl;
    }

    A()
    {
#ifdef __WINDOWSJQ_
        InitializeCriticalSection(&my_winsec);    //    用临界区之前要初始化
#endif // __WINDOWSJQ_

    }

private:
    list<int> msgRecvQueue;
    mutex my_mutex;

#ifdef __WINDOWSJQ_
    CRITICAL_SECTION my_winsec;    //    windows中的临界区，非常类似C++11中的mutex
#endif // __WINDOWSJQ_

};

int main()
{
    A myobj;
    thread    myInMsgObj(&A::inMsgRecvQueue, &myobj);
    thread    myOutMsgObj(&A::outMsgRecvQueue, &myobj);
    myInMsgObj.join();
    myOutMsgObj.join();

    getchar();
    return 0;
}

　　使用RAII实现windows版的lock_guard<>

class CWinLock {
public:
    CWinLock(CRITICAL_SECTION *pCritmp)
    {
        my_winsec =pCritmp;
        EnterCriticalSection(my_winsec);
    }
    ~CWinLock()
    {
        LeaveCriticalSection(my_winsec)
    };
private:
    CRITICAL_SECTION *my_winsec;
};

 

std::recursive_mutex嵌套锁/递归锁

　　std::recursive_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

　　例如函数a需要获取锁mutex，函数b也需要获取锁mutex，同时函数a中还会调用函数b。如果使用std::mutex必然会造成死锁。但是使用std::recursive_mutex就可以解决这个问题。

 

参考

https://blog.csdn.net/qq_38231713/article/details/106093490