C++：并发与多线程（十一）

最新推荐文章于 2024-04-19 09:00:00 发布
最新推荐文章于 2024-04-19 09:00:00 发布
阅读量140 收藏 3
点赞数 1
分类专栏： C++并发与多线程 文章标签： 队列 c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dddgggd/article/details/118407054
版权

Windows临界区、其他各种mutex互斥量

一 windows临界区

windows下的临界区类似于C+11的mutex，都是进入临界区，执行函数，离开临界区

CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex

InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化

EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock

LeaveCriticalSection(&my_winsec); //离开临界区

示例代码

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;

#define __WINDOWS_




class A
{
public:
    //把玩家命令放入到一个队列的进程
    std::unique_lock<std::mutex>rtn_unique_lock()
    {
        std::unique_lock<std::mutex>temguard(my_mutex1);
        return temguard;

    }
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 100; i++)
        {
            {
                cout << "inMsgRecvQueue insert:" << i << endl;
#ifdef __WINDOWS_
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
                LeaveCriticalSection(&my_winsec); //离开临界区
#endif

            }
        }
    }

    //读取命令的线程
    void outMsgRecvQueue() {
        int command = 0;
        while (true) {
#ifdef __WINDOWS_
            EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                LeaveCriticalSection(&my_winsec); //离开临界区
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }
            LeaveCriticalSection(&my_winsec); //离开临界区

#endif
        }
    }


    A()
    {
#ifdef __WINDOWS_
        InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化
#endif
    }
private:

    std::list<int>msgRecvQueue;
    mutex my_mutex1;           //创建一个互斥量
    condition_variable my_cond;  //生成一个条件变量对象

#ifdef __WINDOWS_
    CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex
#endif
};

int main()
{

    //Windows的临界区



    A myobja;
    thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
    thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
    myOutnMsg.join();
    myInMsgObj.join();
}

二 多次进入临界区试验

在同一个线程，windows中的“相同的临界区变量”代表的临界区允许多次进入，但是调用几次进入就要调用几次离开，在C++11中不允许这样操作

    //允许重复进入临界区 ，但必须进入几次，离开几次
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
                LeaveCriticalSection(&my_winsec); //离开临界区
                LeaveCriticalSection(&my_winsec); //离开临界区

示例：

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;

#define __WINDOWS_




class A
{
public:
    //把玩家命令放入到一个队列的进程
    std::unique_lock<std::mutex>rtn_unique_lock()
    {
        std::unique_lock<std::mutex>temguard(my_mutex1);
        return temguard;

    }
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 100; i++)
        {
            {
                cout << "inMsgRecvQueue insert:" << i << endl;
#ifdef __WINDOWS_
                //允许重复进入临界区 ，但必须进入几次，离开几次
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
                LeaveCriticalSection(&my_winsec); //离开临界区
                LeaveCriticalSection(&my_winsec); //离开临界区
#endif

            }
        }
    }

    //读取命令的线程
    void outMsgRecvQueue() {
        int command = 0;
        while (true) {
#ifdef __WINDOWS_
            EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                LeaveCriticalSection(&my_winsec); //离开临界区
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }
            LeaveCriticalSection(&my_winsec); //离开临界区

#endif
        }
    }


    A()
    {
#ifdef __WINDOWS_
        InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化
#endif
    }
private:

    std::list<int>msgRecvQueue;
    mutex my_mutex1;           //创建一个互斥量
    condition_variable my_cond;  //生成一个条件变量对象

#ifdef __WINDOWS_
    CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex
#endif
};

int main()
{

    //一Windows的临界区

    //二 多次进去临界区
//在同一个线程，windows中的“相同的临界区变量”代表的临界区允许多次进入，
// 但是调用几次进入就要调用几次离开，在C++11中不允许这样操作

    A myobja;
    thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
    thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
    myOutnMsg.join();
    myInMsgObj.join();
}

三 自动析构技术

在C++11中，使用std::lock_guardstd::mutexsbguard(my_mutex);可以在当前程序段执行结束自动解锁

 std::lock_guard<std::mutex>sbguard(my_mutex1);
 msgRecvQueue.push_back(i);

 std::lock_guard<std::mutex>sbguard(my_mutex1);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

示例

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;

//#define __WINDOWS_




class A
{
public:
    //把玩家命令放入到一个队列的进程
    std::unique_lock<std::mutex>rtn_unique_lock()
    {
        std::unique_lock<std::mutex>temguard(my_mutex1);
        return temguard;

    }
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 100; i++)
        {
            {
                cout << "inMsgRecvQueue insert:" << i << endl;
#ifdef __WINDOWS_
                //允许重复进入临界区 ，但必须进入几次，离开几次
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
                LeaveCriticalSection(&my_winsec); //离开临界区
                LeaveCriticalSection(&my_winsec); //离开临界区
#else
 std::lock_guard<std::mutex>sbguard(my_mutex1);
 msgRecvQueue.push_back(i);
#endif

            }
        }
    }

    //读取命令的线程
    void outMsgRecvQueue() {
        int command = 0;
        while (true) {
#ifdef __WINDOWS_
            EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                LeaveCriticalSection(&my_winsec); //离开临界区
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }
            LeaveCriticalSection(&my_winsec); //离开临界区

#else
            std::lock_guard<std::mutex>sbguard(my_mutex1);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

#endif
        }
    }

    A()
    {
#ifdef __WINDOWS_
        InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化
#endif
    }
private:

    std::list<int>msgRecvQueue;
    mutex my_mutex1;           //创建一个互斥量
    condition_variable my_cond;  //生成一个条件变量对象

#ifdef __WINDOWS_
    CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex
#endif
};

int main()
{
    A myobja;
    thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
    thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
    myOutnMsg.join();
    myInMsgObj.join();
}

而在Windows下，如果我们想实现这个功能，可以借助类对象的析构来完成
该类称为RAII类，即 资源获取即初始化
容器，智能指针都称为RAII类 其对象称为 RAII对象

//本类用于自动释放windows下的临界区，防止忘记离开临界区导致的死锁，类似于C++11的lock_guard
class CWinLock
{
public:
    CWinLock(CRITICAL_SECTION *pcr)
    {
        m_pCritical  = pcr;
        //进入临界区
        EnterCriticalSection(m_pCritical);
    }
    ~CWinLock()
    {
        LeaveCriticalSection(m_pCritical); //离开临界区

    }


private:
    CRITICAL_SECTION* m_pCritical;
};

在需要保护的临界区前初始化一个该类的对象，程序结束后该对象自动析构，会调用析构函数，析构函数内离开临界区，并且多次创建也没问题，多次创建对象就会多次析构对象，就会多次离开临界区。

          CWinLock cwlock(&my_winsec);
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

示例

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;

#define __WINDOWS_

//本类用于自动释放windows下的临界区，防止忘记离开临界区导致的死锁，类似于C++11的lock_guard
class CWinLock
{
public:
    CWinLock(CRITICAL_SECTION *pcr)
    {
        m_pCritical  = pcr;
        //进入临界区
        EnterCriticalSection(m_pCritical);
    }
    ~CWinLock()
    {
        LeaveCriticalSection(m_pCritical); //离开临界区

    }


private:
    CRITICAL_SECTION* m_pCritical;
};

class A
{
public:
    //把玩家命令放入到一个队列的进程
    std::unique_lock<std::mutex>rtn_unique_lock()
    {
        std::unique_lock<std::mutex>temguard(my_mutex1);
        return temguard;

    }
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 100; i++)
        {
            {
                cout << "inMsgRecvQueue insert:" << i << endl;
#ifdef __WINDOWS_
                //允许重复进入临界区 ，但必须进入几次，离开几次
//                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
//                EnterCriticalSection(& my_winsec) ;  //windows下的进入临界区，相当于lock
                CWinLock cwlock(&my_winsec);
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
//                LeaveCriticalSection(&my_winsec); //离开临界区
//                LeaveCriticalSection(&my_winsec); //离开临界区
#else
 std::lock_guard<std::mutex>sbguard(my_mutex1);
 msgRecvQueue.push_back(i);
#endif

            }
        }
    }

    //读取命令的线程
    void outMsgRecvQueue() {
        int command = 0;
        while (true) {
#ifdef __WINDOWS_
            CWinLock cwlock(&my_winsec);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

#else
            std::lock_guard<std::mutex>sbguard(my_mutex1);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

#endif
        }
    }


    A()
    {
#ifdef __WINDOWS_
        InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化
#endif
    }
private:

    std::list<int>msgRecvQueue;
    mutex my_mutex1;           //创建一个互斥量
    condition_variable my_cond;  //生成一个条件变量对象

#ifdef __WINDOWS_
    CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex
#endif
};

int main()
{

    A myobja;
    thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
    thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
    myOutnMsg.join();
    myInMsgObj.join();
}

四 recursive mutex递归的独占互斥量

当使用普通mutex上锁时，如果同一线程的同一个锁被多次lock，会出现异常，C++11不允许这么做
mutex 称为独占互斥量
例如

  void testFunc1()
    {
        std::lock_guard<std::mutex>sbguard(my_mutex1);
        cout<<"testFunc1"<<endl;
        testFunc2(); //调用两次my_mutex1，系统崩溃
    }
    void testFunc2()
    {
        std::lock_guard<std::mutex>sbguard(my_mutex1);
        cout<<"testFunc2"<<endl;
        testFunc3();
    }
    void testFunc3()
    {
        std::lock_guard<std::mutex>sbguard(my_mutex1);
        cout<<"testFunc3"<<endl;
    }

    A myobja;
    thread myobj(&A::testFunc1, &myobja);
    myobj.join();
}

打印结果：程序卡在Func1无法执行

G:\CSlrn\C++Code\MultiThread\2_12\cmake-build-debug\2_12.exe
testFunc1

recursive_mutex允许同一个线程的同一个互斥量多次被lock
我们将mutex改为recursive_mutex，程序可以正常运行
示例

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;
class A
{
public:
void testFunc1()
    {
        std::lock_guard<std::recursive_mutex>sbguard(my_mutex1);
        cout<<"testFunc1"<<endl;
        testFunc2(); //调用两次my_mutex1，系统崩溃
    }
    void testFunc2()
    {
        std::lock_guard<std::recursive_mutex>sbguard(my_mutex1);
        cout<<"testFunc2"<<endl;
        testFunc3();
    }
    void testFunc3()
    {
        std::lock_guard<std::recursive_mutex>sbguard(my_mutex1);
        cout<<"testFunc3"<<endl;
    }
    private:

    recursive_mutex my_mutex1;           //创建一个递归独占互斥锁
 };

 int main()
{  
    A myobja;
    thread myobj(&A::testFunc1, &myobja);
    myobj.join();
}

打印结果
程序不会发生异常，即使是将my_mutex1多次调用，程序正常执行

G:\CSlrn\C++Code\MultiThread\2_12\cmake-build-debug\2_12.exe
testFunc1
testFunc2
testFunc3

Process finished with exit code 0

其缺点是效率比mutex差一些，递归太多可能会出现异常。

五 带超时的互斥量std: timed_mutex和std: recursive_timed_mutex

  • timed_mutex带超时的独占互斥量
  • timed_mutex提供了两个接口：
    1.try_lock_for();等待一段时间，如果拿到了锁或者超时没拿到锁，那么流程继续往下走
    2.try_lock_until(); 参数为某一个未来的时间点，在达到该时间点前，拿到了锁则执行任务函数，程序往下走，如果没拿到，程序也往下走，不卡住。
  • recursive_timed_mutex 带超时的递归独占互斥量，recursive_timed_mutex 带超时的递归独占互斥量 与recursive_mutex功能类似，其带有超时功能

1. timed_mutex的try_lock_for()接口

测试用例：将outmsg函数的锁拿一个非常久的时间，观察inmsg的拿锁情况
outmsg函数内：

 std::lock_guard<std::timed_mutex>sbguard(my_mutex1);
            //拿到锁不放开 测试timed_mutex功能
            std::chrono::milliseconds sleeptime(100000);

inmsg函数内：拿到锁了则执行任务函数，没拿到锁则进行接下来的操作，程序不会像独占互斥量那样卡在一个地方

std::chrono::microseconds timeout(100);
 if (my_mutex1.try_lock_for(timeout))
 {
     //在100ms内拿到了锁
     cout<<"get_mutex"<<endl;
     msgRecvQueue.push_back(i);
     my_mutex1.unlock();
 }
 else //没拿到锁
 {
     cout<<"not get_mutex"<<endl;
     std::chrono::microseconds sleeptime(100);
     std::this_thread::sleep_for(sleeptime);
 }
 cout<<"go on"<<endl;

完整例子

#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
#include <condition_variable>
#include <windows.h>
using namespace std;

//#define __WINDOWS_
class CWinLock
{
public:
    CWinLock(CRITICAL_SECTION *pcr)
    {
        m_pCritical  = pcr;
        //进入临界区
        EnterCriticalSection(m_pCritical);
    }
    ~CWinLock()
    {
        LeaveCriticalSection(m_pCritical); //离开临界区

    }


private:
    CRITICAL_SECTION* m_pCritical;
};

class A
{
public:
    //把玩家命令放入到一个队列的进程
    std::unique_lock<std::timed_mutex>rtn_unique_lock()
    {
        std::unique_lock<std::timed_mutex>temguard(my_mutex1);
        return temguard;

    }
    void inMsgRecvQueue()
    {
        for (int i = 0; i < 100; i++)
        {
            {
                cout << "inMsgRecvQueue insert:" << i << endl;
#ifdef __WINDOWS_
                CWinLock cwlock(&my_winsec);  //cwlock RAII对象
                msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

#else
 std::chrono::microseconds timeout(100);
 if (my_mutex1.try_lock_for(timeout))
 {
     //在100ms内拿到了锁
     cout<<"get_mutex"<<endl;
     msgRecvQueue.push_back(i);
     my_mutex1.unlock();
 }
 else //没拿到锁
 {
     cout<<"not get_mutex"<<endl;
     std::chrono::microseconds sleeptime(100);
     std::this_thread::sleep_for(sleeptime);
 }
cout<<"go on"<<endl;
#endif

            }
        }
    }

    //读取命令的线程
    void outMsgRecvQueue() {
        int command = 0;
        while (true) {
#ifdef __WINDOWS_
            CWinLock cwlock(&my_winsec);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

#else
            std::lock_guard<std::timed_mutex>sbguard(my_mutex1);
            //拿到锁不放开 测试timed_mutex功能
            std::chrono::milliseconds sleeptime(100000);
            std::this_thread::sleep_for(sleeptime);
            if(!msgRecvQueue.empty())
            {
                command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                cout<<"outMsgRecvQueue get :"<<command<<endl;
            }

#endif
        }
    }


    A()
    {
#ifdef __WINDOWS_
        InitializeCriticalSection(& my_winsec) ;  //windows下的临界区初始化
#endif
    }

private:

    std::list<int>msgRecvQueue;
    std::timed_mutex my_mutex1;

#ifdef __WINDOWS_
    CRITICAL_SECTION  my_winsec;  //windows下的临界区 类似于C++11的mutex
#endif
};

int main()
{

    A myobja;
    thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
    thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
    myOutnMsg.join();
    myInMsgObj.join();
}

打印结果：try_lock_for一直在尝试拿锁，拿到锁则执行任务函数，执行完程序继续往下走
如果在100us没拿到锁，则程序还是继续往下执行。

G:\CSlrn\C++Code\MultiThread\2_12\cmake-build-debug\2_12.exe
inMsgRecvQueue insert:0
not get_mutex
go on
inMsgRecvQueue insert:1
not get_mutex
go on
inMsgRecvQueue insert:2
not get_mutex
go on
inMsgRecvQueue insert:3
not get_mutex
go on
inMsgRecvQueue insert:4
not get_mutex
go on
inMsgRecvQueue insert:5
not get_mutex
go on
.
.
.
.
inMsgRecvQueue insert:97
not get_mutex
go on
inMsgRecvQueue insert:98
not get_mutex
go on
inMsgRecvQueue insert:99
not get_mutex
go on
Michael.Scofield
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++11 线程支持库----互斥
沧浪之水清兮
08-21 582
互斥：   #include&lt;mutex&gt;     mutex:提供基本互斥设施  std::mutex 互斥算法避免多个线程同时访问共享资源。这会避免数据竞争，并提供线程间的同步支持。 mutex 类是能用于保护共享数据免受从多个线程同时访问的同步原语。 mutex 提供排他性非递归所有权语义： 调用方线程从它成功调用 lock 或 try_lock 开始，到它调用 unl...
C++ 并发多线程日志处理
02-28
在C++编程中，多线程日志处理是一项重要的任务，尤其在高并发环境中，能够有效地记录、管理和分析系统运行时的信息。C++11引入了标准库中的`<thread>`，使得多线程编程变得更加方便，同时也为日志处理带来了新的挑战...
C++新特性34_递归互斥量recursive_mutex与超时互斥量timed_mutex的使用（递归互斥量解决同一线程重复使用互斥量的需求；超时互斥量设置等待超时机制；解决互斥量阻塞问题）
分享学习成长历程，Winter is coming！
03-08 1245
接上篇C++新特性33_死锁产生的原因及避免（线程在等待一个永远都不能成功的条件成立，从而进入到陷入休眠，永远不能被唤醒的状态、通过调整锁的使用顺序解决死锁问题），本篇将会学习互斥体的相关知识。 1. 互斥量 在C++11中除了提供mutex之外还会提供其他三种加强版的mutex，C++11 中提供以下4种语义的互斥量(mutex)： std::mutex: 独占的互斥量，不能递归使用 std::recursive_mutex: 递归互斥量，不带超时功能 std::timed_mutex: 带超时的独占互
C++多线程编程之timed_mutex
llb_1203的博客
08-13 465
参考www.cplusplus.com 文章目录std::timed_mutex构造函数析构函数timed_mutex::locktimed_mutex::try_locktimed_mutex::try_lock_fortimed_mutex::try_lock_untiltimed_mutex::unlocktimed_mutex::native_handle std::timed_mutex timed_mutex功能与普通的mutex类似，仅多了两个成员函数try_lock_for和try_lock
C++11 新特性：多线程支持 - std::timed_mutex
最新发布
kelvin_yin的专栏
04-19 371
可以让线程在等待获取互斥量的过程中考虑超时，这对于需要避免长时间等待的场景特别有用。
《c++11学习笔记》 --- 线程
ccr的博客
12-12 982
创建线程： 使用std::thread创建线程，只需要提供线程函数或者线程对象。并且可以同时指定线程函数的参数。 void func() { } int main() { std::thread t(func); t.join(); return 0; } join函数会阻塞线程，直到线程函数执行结束，如果线程函数有返回值，返回值将被忽略。 detach()方法，将线程和线程对象分离，线程不被阻塞执行。 void func() { } int main() { std::
C++11互斥量mutex详解，再也不怕多线程的数据竞争！
Lion_Long的博客
02-07 5055
mutex又称互斥量，C++ 11中与 mutex相关的类（包括锁类型）和函数都声明在头文件中，所以如果你需要使用 std::mutex，就必须包含头文件。std::mutex，独占的互斥量，不能递归使用。std::time_mutex，带超时的独占互斥量，不能递归使用。std::recursive_mutex，递归互斥量，不带超时功能。std::recursive_timed_mutex，带超时的递归互斥量。
C++11 并发指南之多线程初探
12-20
Linux 程序员都用过 Pthread, 但有了 C++11 的 std::thread 以后，你可以在语言层面编写多线程程序了，直接的好处就是多线程程序的可移植性得到了很大的提高，所以作为一名 C++ 程序员，熟悉 C++11 的多线程编程方式...
C++并发与多线程
08-30
非常不错，值得收藏
C++11的多线程并发编程（一）
01-20
C++11的多线程并发编程（一） 在疫情期间以及未来毕业后即将工作的憧憬中，给自己立个学习flag，学习并第一次通过CSDN记录下C++11的多线程并发编程。初学者的我写的不好，还望大家多多指正与批评， 学习多线程并发...
C++并发与多线程-运行时选择线程数量
01-20
使用std::thread::hardware_concurrency() 来获得当前系统可以真正并发的线程数量，和cpu的核心数有关。... 创建一个线程： << std::this_thread::get_id() << std::endl; } ~accumulate_block() {
c++11互斥库mutex的使用
04-09
c++11多线程库中互斥库模块的使用方式，介绍了mutex类和time_mutex类的使用方式
C++11新特性——互斥锁、条件变量、原子类型
m0_67168421的博客
12-13 2167
C++
c++多线程，timed_mutex
tianlanl10的博客
05-31 343
timed_mutex constructor constexpr timed_mutex() no_exception; //object unlock state timed_mutex(const timed_mutex&) = delete; //不能拷贝或移动拷贝 构建过程不是原子操作，所以在构建过程可能会出现data race; void lock(); void unlock(); bool try_lock(); 和mutex的lock/unlock/tyr_lock同；
C++11之超时锁timed_mutex
KingOfMyHeart的博客
08-12 398
超时锁：用来记录线程加锁 解锁 等竞争锁的过程，多用于调试多线程时使用。
C++并发多线程--std::recursive_mutex和std::timed_mutex的使用
牵一只蜗牛去散步
08-21 244
std::recursive_mutex 创建递归的独占互斥量，允许一个线程对其多次加锁和解锁；是直到某一时间内都在尝试获取锁，如果超过了规定的时间点仍无法获取锁，线程就会继续执行（跳过临界区的内容）；等待一段时间来尝试获取锁，若无法获取锁，则线程继续执行（跳过临界区的内容）；1--std::recursive_mutex的使用。1--std::recursive_mutex的使用。2--std::timed_mutex的使用。带有超时功能的独占互斥量，
C++11 timed_mutex
程序员Link
10-12 2036
目录一 timed_mutex二 try_lock_for三 try_lock_until四 recursive_timed_mutex五 参考 一 timed_mutex 前文C++11 std::mutex中介绍了，mutex 均具有 lock、 try_lock、unlock等成员函数。 timed_mutex 增加了带时限的 try_clock。即 try_lock_for、try_lock_until。 定义 // 头文件 <mutex> class timed_mutex
c++多线程（十九） - std::timed_mutex
万里归来少年心
05-04 5675
mutex获取和释放锁如下： mutex myMutex; myMutex.lock(); //业务代码 myMutex.unlock(); 当mutex获取锁失败时，线程会一直阻塞。 timed_mutex带超时功能。在规定的等待时间内，没有获取锁，线程不会一直阻塞，代码会继续执行。 timed_mutex myMutex; chrono::milliseco...
c++ concurrency in action笔记
03-25
C++ Concurrency in Action笔记详细介绍了C++11版本引入的多线程支持，以及如何在C++编程中有效地管理和利用并发。首先，C++11提供了对多线程的内置支持，使得并发编程成为可能，通过并发可以实现关注点分离和提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael.Scofield

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值