C++标准库多线程同步机制互斥量总结

简单的多线程同步机制，互斥量使用实例：

//文件：main.cpp
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include "CSingleton.h"

using namespace std;
/*
1.defer_lock_t 表示不要求拥有mutex的所有权
2.try_to_lock_t 以非阻塞的方式去尝试获取mutex的所有权
3.adopt_lock_t 假定调用线程已经获取到了mutex的所有权
*/

mutex g_mutex;                      //互斥锁
timed_mutex g_tMutex;               //时间锁，限制最大阻塞时间
recursive_mutex g_rMutex;           //线程内可重复锁
recursive_timed_mutex g_rTMutex;    //线程内可重复时间锁
condition_variable g_cond1;         //条件变量

void ReadData(){};
void WriteData(){};

int main()
{
    //mutex
    {
        g_mutex.lock();
        cout << "g_mutex.lock()" << endl;
        g_mutex.unlock();

        if (g_mutex.try_lock())
        {
            cout << "g_mutex.try_lock()" << endl;
            g_mutex.unlock();
        }
    }
    //time mutex
    {
        std::lock_guard<std::timed_mutex> lock(g_tMutex);       //g_tMutex.lock();
        auto now = std::chrono::steady_clock::now();
        bool result = g_tMutex.try_lock_until(now + std::chrono::seconds(5));
        cout << "g_tMutex.try_lock_until() 5 seconds" << endl;
        //g_tMutex.unlock();
    }
    //recursive mutex
    {
        g_rMutex.lock(); 
        if (g_rMutex.try_lock()) {                          //to lock it again
            std::cout << "lock acquired" << std::endl;
            g_rMutex.unlock();
        }
        else {
            std::cout << "lock not acquired" << std::endl;
        }
        g_rMutex.unlock();
    }

    {
        //shared_lock<mutex> lock(g_mutex);//共享锁，可以用做读锁,可以多线程同时读取数据,C++17支持的接口
        ReadData();
        lock_guard<mutex> lock(g_mutex); //自动上锁解锁，不能传值
        WriteData();
        cout << "lock_guard<mutex> lock(g_mutex)" << endl;
    }

    {
        unique_lock<mutex> lock(g_mutex);//自动上锁解锁，可以传值
        cout << "unique_lock<mutex> lock(g_mutex)" << endl;
    }

    {
        lock(g_mutex, g_rMutex); //使用多个锁的时候，使用lock()避免死锁
        
    }

    //call_once()和once_flag实现单例
    {
        CSingleton *instance = CSingleton::GetInstance();
    }
    return 0;
}

单例的call_once()实现：

//文件： CSingleton.h

#include <thread>
#include <mutex>
#include <condition_variable>

class CSingleton
{
private:
    CSingleton();
    static void Init()
    {
        if (m_instanse == nullptr)
            m_instanse = new CSingleton();
    };

public:
    ~CSingleton();

    static CSingleton * GetInstance()
    {
        std::call_once(m_initOnceFlag, Init);
        return m_instanse;
    };

private:
    static CSingleton *m_instanse;
    static std::once_flag m_initOnceFlag;
}; 
CSingleton* CSingleton::m_instanse = nullptr;

这个单例实现不知道有没有更好的方式，如有欢迎评论提出。

学习链接：https://blog.csdn.net/lgyxdn/article/details/100537540