【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