C++11 多线程编程 12.windows临界区、其他各种mutex互斥量

#include<iostream>
#include<mutex>
#include<future>
#include<vector>
#include<queue>
#include<list>
#include<Windows.h>
//#define __WINDOWSJQ_//处于定义状态
using namespace std;

//本类用于自动释放windows下的临界区，防止忘记EnterCriticalSection的离开,导致死锁。类似于C++11的std::lock_guard
class CWinLock//叫RAII类，（Resource Acquisition is initialzation）中文意思是资源获取即初始化；
            //容器，智能智能，都属于RAII类。
{
public:
    CWinLock(CRITICAL_SECTION *PCritmp) {
        this->m_pCritical = PCritmp;
        EnterCriticalSection(m_pCritical);
    }
    ~CWinLock() {
        LeaveCriticalSection(m_pCritical);
    }

private:
    CRITICAL_SECTION* m_pCritical;
};

class A
{
public:
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 10000; i++) {
            cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
#ifdef __WINDOWSJQ_

            //EnterCriticalSection(&my_winsec);//进入临界区（加锁）
            //EnterCriticalSection(&my_winsec);//两次进入临界区windows允许的，但是必须得两次离开临界区，如果离开一次，还有一个没有离开，就相当于有一把锁
            CWinLock WimLock(&my_winsec);//自己写的类，类似于lock_guard；windows下可以自己实现
            CWinLock WimLock2(&my_winsec);//调用多次也没事。
            MsgRecvQueue.push_back(i);
            //LeaveCriticalSection(&my_winsec);
            //LeaveCriticalSection(&my_winsec);//离开临界区（解锁）
#else

            //my_mutex.lock();因为要讲第三个知识点，所以先注释掉
            //my_mutex.lock();报异常，C++11不允许两次加锁。和windows有区别

            //std::lock_guard<std::mutex> sbguard(my_mutex);
            //std::lock_guard<std::recursive_mutex> sbguard(my_mutex1);//这个可以多次加锁
            //this->function1();//此处加了三次锁，肯定报异常（只要lock超过一次就报异常）
            //std::lock_guard<std::mutex> sbguard(my_mutex);//无论是lock还是lock_guard都会报异常

            希望等待1000ms ，1000ms拿不到锁就往下走 try_lock_for
            //std::chrono::milliseconds timeout(1000);
            //if (my_mutex2.try_lock_for(timeout)) {//等待1000毫秒尝试获取锁
            //    //在这100ms内拿到了锁，
            //    MsgRecvQueue.push_back(i);
            //    my_mutex2.unlock();
            //}
            //else {
            //    //这次没拿到锁，
            //    std::chrono::milliseconds sleeptime(100);
            //    std::this_thread::sleep_for(sleeptime);
            //}
            //希望等待1000ms ，1000ms拿不到锁就往下走

            //try_lock_until
            std::chrono::milliseconds timeout(1000);
            if (my_mutex2.try_lock_until(chrono::steady_clock::now()+ timeout)) {//等现在的时间+1000毫秒，就是这个格式，记住就好
                //在这1000毫秒内拿到了锁
                MsgRecvQueue.push_back(i);
                my_mutex2.unlock();
            }
            else {
                //这次没拿到锁，
                std::chrono::milliseconds sleeptime(100);
                std::this_thread::sleep_for(sleeptime);
            }

            MsgRecvQueue.push_back(i);
            //my_mutex.unlock();
            //my_mutex.unlock();
#endif
        }
    }

    bool outMsgLULProc(int& command) {
#ifdef __WINDOWSJQ_
        EnterCriticalSection(&my_winsec);
        if (!MsgRecvQueue.empty()) {
            command = MsgRecvQueue.front();
            MsgRecvQueue.pop_front();
            LeaveCriticalSection(&my_winsec);
            return true;
        }
        LeaveCriticalSection(&my_winsec);
#else
        my_mutex.lock();
        if (!MsgRecvQueue.empty()) {
            command = MsgRecvQueue.front();
            MsgRecvQueue.pop_front();
            my_mutex.unlock();
            return true;
        }
        my_mutex.unlock();
#endif
        return false;
    }

    void outMsgRecvQueue() {
        int command = 0;
        for (int i = 0; i < 10000; i++) {
            bool result = outMsgLULProc(command);
            if (result == true) {
                cout << "outMsgRecvQueue执行，取出一个元素 " << command << endl;
                //这里可以考虑元素处理。
            }
            else {
                cout << "outMsgRecvQueue执行，目前还是空元素" << endl;
            }
        }
        cout << "end" << endl;
    }

    A()
    {

#ifdef __WINDOWSJQ_
        InitializeCriticalSection(&my_winsec);//用临界区之前必须初始化。
#endif
    }

    //void function1() {
    //    //std::lock_guard<std::mutex> sblock1(my_mutex);会报错，多次加锁
    //    std::lock_guard<std::recursive_mutex> sblock1(my_mutex1);//不会报错，多次加锁也可以
    //    //。。。干各种事情
    //    function2();//这块会崩溃，加了两次锁。
    //}
    //void function2() {
    //    std::lock_guard<std::mutex> sblock1(my_mutex);
    //    //std::lock_guard<std::mutex> sblock1(my_mutex); 会报错，多次加锁
    //    //。。。干各种事情
    //}
private:
    std::mutex my_mutex;
    std::list<int>  MsgRecvQueue;
    std::recursive_mutex my_mutex1;
    std::timed_mutex my_mutex2;
    
#ifdef __WINDOWSJQ_
    CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于C++11中的mutex
#endif // __WINDOWSJQ_

};
int main()
{
    /*    （1）windows临界区
    *        先define一个变量，再定义临界区，初始化临界区，用#ifdef #else #endif使用临界区
    *    （2）多次进入临界区实验
    *        在同一个线程中（不同线程就会卡住等待）,windows中的相同“临界区变量”代表的临界区的进入EnterCriticalSection（）可以被多次调用
    *            但是调用了几次进入临界区，就得调用几次离开临界区，数量必须相等
    *        结论：windows允许多次进入临界区，但是进入多少次就必须离开多少次
    *              C++11不允许多次加锁，否则报异常
    *    （3）自动析构技术
    *        std::lock_guard<std::mutex>
    *        windows下没有相关这种功能的类，自己写一个类，构造函数中进入临界区，析构函数中离开临界区，再调用就可以实现该功能。
    *    （4）recursive_mutex递归的独占使用互斥量，如果加锁次数太多还是会报异常。，
    *        std::mutex  独占互斥量，自己拿到锁时候，其他线程lock不了
    *        recursive_mutex 递归的独占互斥量：允许同一个互斥量多次被.lock()，效率上要比mutex差。
    *        recursive_mutex也有lock（）。也有unlock（）；
    *        考虑代码是否有优化空间，用了这个独占互斥量
    *    （5）带超时的互斥量std::timed_mutex和std::recursive_timed_mutex    
    *        std::timed_mutex：是带超时的独占互斥量
    *            平常如果拿不到锁，就会一直卡在那等待拿锁，用这个带超时的互斥量，等待一段时间拿锁，如果拿不到，程序还是能走下来
    *            try_lock_for():,参数是一段时间，等待一段时间，如果拿到了锁，或者等待超时，没拿到锁，流程继续往下走，
    *            try_lock_unit()：参数是一个未来时间点。在这个未来的时间没到的时间段内，如果拿到了锁，那么就走下来，如果时间到了，没拿到锁，我还是走下来
    *        std::recursive_timed_mutex    是带超时的递归独占互斥量（ 允许同一个线程多次获取这个互斥量）
    */
    A myobja;
    std::thread myoutnMsgObj(&A::outMsgRecvQueue, &myobja);//注意这个第二个参数必须是引用，才能保证线程里用的是同一个对象。
    std::thread myinMsgObj(&A::inMsgRecvQueue, &myobja);
    myoutnMsgObj.join();
    myinMsgObj.join();
    return 0;
}