多线程共享数据的保护+互斥量概念、用法、死锁演示及解决详解(std::lock()、std::adopt_lock)

最新推荐文章于 2023-07-28 11:31:26 发布
最新推荐文章于 2023-07-28 11:31:26 发布
阅读量1.1k 收藏 9
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HITXJ/article/details/108439190
版权 
#include <list>
#include <thread>

class A
{
public:
    //把收到的消息（玩家命令）入到一个队列的线程
    void inMsgRecvQueue()
    {
        for (int i = 0;i < 100000;++i)
        {
            cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
            msgRecvQueue.push_back(i);
        }
    }

    //把数据从消息队列中取出的线程
    void outMsgRecvQueue()
    {
        for (int i = 0;i < 100;i++)
        {
            if (!msgRecvQueue.empty())
            {
                int command = msgRecvQueue.front();
                msgRecvQueue.pop_front();
                //这里考虑处理数据
            }
            else
            {
                cout << "outMsgRecvQueue()执行，但是目前消息队列中为空" << endl;
            }
        }
        
    }

private:
    std::list<int> msgRecvQueue;    //容器,专门用于代表玩家给咱们发送过来的命令
};

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

    return 0;
}

保护共享数据，操作时某个线程用代码把共享数据锁住，操作数据、解锁；
其他想操作共享数据的线程必须等待解锁，锁定住，操作，解锁。

一、互斥量的概念

互斥量（mutex）的基本概念，多个线程尝试用lock()成员函数来加锁这把锁头，只有一个线程能锁定成功（成功的标志是lock()函数返回）
如果没锁成功，那么流程卡在lock()这里不断尝试去锁这把锁头

二、互斥量的用法

#include <mutex>

2.1 lock() unlock()

步骤：先lock()，操作共享数据，再unlock()，每调用一次lock()，必然应该调用一个unlock()

#include <list>
#include <thread>
#include <mutex>

class A
{
public:
    //把收到的消息（玩家命令）入到一个队列的线程
    void inMsgRecvQueue()
    {
        for (int i = 0;i < 100;++i)
        {
            cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
            my_mutex.lock();
            msgRecvQueue.push_back(i);
            my_mutex.unlock();
        }
    }

    bool outMsgLULProc(int& command)
    {
        my_mutex.lock();
        if (!msgRecvQueue.empty())
        {
            command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            my_mutex.unlock();
            return true;
        }
        my_mutex.unlock();
        return false; 
    }

    //把数据从消息队列中取出的线程
    void outMsgRecvQueue()
    {
        int command = 0;
        for (int i = 0;i < 100;i++)
        {
            bool result = outMsgLULProc(command);
            if (result == true)
            {
                cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
                //可以考虑对命令(数据)进行处理
            }
            else
            {
                cout << "outMsgRecvQueue()执行，但是目前消息队列中为空" << i << endl;
            }
        }
        cout << "end" << endl;
    }

private:
    std::list<int> msgRecvQueue;    //容器,专门用于代表玩家给咱们发送过来的命令
    std::mutex my_mutex; //创建一个互斥量 
};

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

    return 0;
}

为了防止大家忘记unlock()，引入了一个叫std::lock_guard()的类模板：你忘记unlock()不要紧，我替你unlock()。
学习过智能指针（unique_ptr）：你忘记释放内存不要紧，我替你释放。

2.1 std::lock_guard类模板，直接取代lock()和unlock()，也就是说，用了lock_guard以后，再不能使用lock()和unlock()

记住这种写法：

std::lock_guard<std::mutex> sguard(my_mutex);

其中，my_mutex的定义在：

std::mutex my_mutex1; //创建一个互斥量

生成std::lock_guard<std::mutex>类模板的对象肯定要调用类的构造函数，构造函数里执行了mutex::lock()
sguard是局部对象，局部对象退出函数（return的时候）需要析构，析构函数调用了mutex::unlock()

    bool outMsgLULProc(int& command)
    {
        // my_mutex.lock();
        std::lock_guard<std::mutex> sguard(my_mutex);
        if (!msgRecvQueue.empty())
        {
            command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            // my_mutex.unlock();
            return true;
        }
        // my_mutex.unlock();
        return false; 
    }

lock_guard不够灵活：
lock()、unlock()随时能调用，随时能解锁
lock_guard只能在析构的时候调用解锁

通过大括号可以使得只要到大括号末尾lock_guard就会析构掉
原则：在互斥量包裹的位置之外，不要动共享数据

三、死锁

张三：站在北京等李四，不挪窝；
李四：站在北京等张三，不挪窝；
C++中：
比如有两把锁（死锁这个问题，至少有两个锁头 两个互斥量才能产生）
两个线程A和B

(1)线程A执行的时候，这个线程先锁金锁，把金锁lock()成功了,然后去lock银锁；
出现了上下文切换（此时银锁还没有锁就出现了上下文切换）
个人理解：关键在于两个lock之间发生了上下文切换
(2)线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会lock成功，线程B要去lock金锁
此时此刻，死锁就产生了；
(3)线程A因为拿不到银锁头，流程走不下去（后边代码有解锁金锁头但是流程走不下去，所以金锁头解不开）
(4)线程B因为拿不到金锁头，流程走不下去（后边代码有解锁银锁头但是流程走不下去，所以银锁头解不开）

3.1 死锁演示

#include <list>
#include <thread>
#include <mutex>

class A
{
public:
    //把收到的消息（玩家命令）入到一个队列的线程
    void inMsgRecvQueue()
    {
        for (int i = 0;i < 100000;++i)
        {
            cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
            my_mutex1.lock();
            my_mutex2.lock();
            msgRecvQueue.push_back(i);
            my_mutex2.unlock();
            my_mutex1.unlock();
        }
    }

    bool outMsgLULProc(int& command)
    {
        my_mutex2.lock();
        my_mutex1.lock();
        if (!msgRecvQueue.empty())
        {
            command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            my_mutex1.unlock();
            my_mutex2.unlock();
            return true;
        }
        my_mutex1.unlock();
        my_mutex2.unlock(); 
        return false; 
    }

    //把数据从消息队列中取出的线程
    void outMsgRecvQueue()
    {
        int command = 0;
        for (int i = 0;i < 100000;i++)
        {
            bool result = outMsgLULProc(command);
            if (result == true)
            {
                cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
                //可以考虑对命令(数据)进行处理
            }
            else
            {
                cout << "outMsgRecvQueue()执行，但是目前消息队列中为空" << i << endl;
            }
        }
        cout << "end" << endl;
    }

private:
    std::list<int> msgRecvQueue;    //容器,专门用于代表玩家给咱们发送过来的命令
    std::mutex my_mutex1; //创建一个互斥量 
    std::mutex my_mutex2;
};

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

    return 0;
}

3.2 死锁的一般解决方案

只要保证两个互斥量上锁的顺序保持一致就不会死锁。

3.3 std::lock()函数模板

用来处理多个互斥量的时候才出场

能力：一次锁住两个或者两个以上互斥量(至少两个，多了不限，1个不行)
它不存在这种因为在多个线程中，因为锁的问题导致死锁的风险问题；
std::lock():如果互斥量中有一个没锁柱，他就在那里等着，等着所有互斥量都锁住，他才能往下走(返回)
特点：要么两个互斥量都锁住，要么两个互斥量都没锁住 。
要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。

std::lock(my_mutex1,my_mutex2);
msgRecvQueue.push_back(i);
my_mutex2.unlock();
my_mutex1.unlock();

std::lock 如果遇到一个锁住，一个没锁住，就会把没锁住的那个撒开

3.4 std::lock_guard的std::adopt_lock参数

 std::lock(my_mutex1,my_mutex2);
std::lock_guard<std::mutex> sguard1(my_mutex1,std::adopt_lock);
std::lock_guard<std::mutex> sguard2(my_mutex2,std::adopt_lock);
msgRecvQueue.push_back(i);
// my_mutex2.unlock();
 // my_mutex1.unlock();

曾经讲过

std::lock_guard<std::mutex> sguard1(my_mutex1);

该行代码的含义是：
在该对象的构造函数中会调用互斥量my_mutex1的std::mutex::lock()函数，在析构函数中会调用互斥量my_mutex1的std::mutex::unlock()函数。

而现在的情况是：
std::lock(my_mutex1,my_mutex2);相当于把两个互斥量的std::mutex::lock()函数调用完了，就不希望std::lock_guard<std::mutex> sguard1(my_mutex1);对象的构造函数中再调用std::mutex::lock()函数
而该对象析构时照常，调用my_mutex1和my_mutex2的unlock()函数

std::adopt_lock()是个结构体对象，起一个标记作用。
作用就表示这个互斥量已经lock()，不需要在std::lock_guard<std::mutex>的对象的构造函数里对mutex类对象再lock()了。

总结：
std::lock()一次锁定多个互斥量，谨慎使用（建议一个一个锁）

HITXJ
关注
C++并发编程(5)：std::unique_lock、互斥量所有权传递、锁的粒度
工大机器人工作室
05-13 1561
主要学习介绍C++并行编程的基础知识，做一些学习记录并分享
互斥量概念、用法、死锁演示及解决详解
Scarlett的博客
02-21 968
保护共享数据，操作时，某个线程 用代码把共享数据锁住、操作数据、解锁；其他想操作共享数据的线程必须等待解锁，锁定住，操作，解锁 一、互斥量（mutex）的基本概念 互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功（成功的标志是lock()函数返回），如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。 互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。 二、互斥量的用法 包含mutex 头文件（好像也可以不加） 2.1 loc
C++多线程编程时的数据保护
12-26
在编写多线程程序时，多个线程同时访问某个共享资源，会导致同步的问题，这篇文章中我们将介绍 C++11 多线程编程中的数据保护。 数据丢失 让我们从一个简单的例子开始，请看如下代码：   #include #include #include #include using std::thread; using std::vector; using std::cout; using std::endl; class Incrementer { private: int counter; public:
std::adopt_lock锁的使用
dxgzg的博客
08-25 7947
今天刚C++并发编程实战，看到一个lock_guard<std::mutex>l(mutex,std::adopt_lock);我就一直在想这个是什么东西，从字面意思理解，就是收养个锁，去msdn搜了搜，msdn是这样解释的，我也没看懂，后来看了几篇博客，大概理解了。 正文 adopt_mutex： adopt_lock确实是跟收养了个锁差不多，在test5不带参数的这个函数中，先上锁，然后托管给lock_guard这个类，这个类称为RALL（资源获取就是初始化），退出这个函数，lock_gu
C++ 多线程std::lock_gurad和std::adopt_lock_t
weixin_62953519的博客
10-26 889
首先，std::lock_gurad获取的是引用，当我们给定一个adopt_lock_t的时候，就是说我们承诺我们给的锁已经上锁了，不用二次上锁，如果不给的话，那就是给给定的锁上锁；我之前了解过lock_guard，但是看见代码中他的构造函数的时候，心想std::adopt_lock是什么东西？注意：adopt_lock_t只是一个空结构体，只是起到标记的作用，并没有什么内容上的作用；
c++11 std::defer_lock, std::try_to_lock, std::adopt_lock
李白
09-07 2857
std::adopt_lock Value used as possible argument to the constructor of unique_lock or lock_guard. unique_lock objects constructed with adopt_lock do not lock the mutex object on construction, assuming instead that it is already locked by the current thread
C++日记——Day40：互斥量概念、用法、死锁演示及解决详解、std::lock()模板、std::lock_guard的std::adopt_lock参数
weixin_38278993的博客
03-25 530
互斥量基本概念 保护共享数据，某个线程 用代码把共享数据锁住，其它想操作共享数据线程必须等待解锁 基本过程：锁定，操作，解锁 互斥量：是个类对象。理解成一把锁，多个线程尝试用lock()函数来加锁这把锁头时，只有一个线程能锁定成功。（成功的标志是lock()函数返回），如果没锁成功，那么流程卡在lock()这里不断尝试去锁这把锁头。 慎用lock()保护共享数据不多也不少，少了达不到效果，...
C++11 并发指南之std::mutex详解
12-20
在C++11中，`std::mutex`是并发编程中的基础组件，它提供了一种机制来保护共享资源免受并发访问的影响。互斥量（Mutex）确保在任何时刻只有一个线程能持有对资源的访问权，从而防止数据竞争和其他并发问题。在`...
【学习笔记】C++并发与多线程笔记五：unique_lock详解
Rain_Mic的博客
06-22 1154
本文接上文 【学习笔记】C++并发与多线程笔记四：互斥量(概念、用法、死锁) 的内容，主要纪录 `unique_lock` 的使用方法以及原理。
C++11 defer_lock try_to_lock adopt_lock
程序员Link
10-20 1004
一 类型 1. std::defer_lock_t 、 std::try_to_lock_t 和 std::adopt_lock_t 是用于为 std::lock_guard(C++11) 、 std::scoped_lock(C++14) 、 std::unique_lock(C++11) 和 std::shared_lock(C++17) 指定锁定策略的空结构体标签类型。 2. std::defer_lock 、 std::try_to_lock 和 std::adopt_lock 分别是 std::
并发线程 (2) - C++线程间共享数据【详解：如何使用锁操作】
weixin_30197685的博客
06-04 1636
具体哪个线程按何种方式访问什么数据？还有，一旦改动了数据，如果牵涉到其他线程，它们要在何时以什么通信方式获得通知？同一进程内的多个线程之间，虽然可以简单易行地共享数据，但这不是绝对的优势，优势甚至是很大的劣势。不正确使用共享数据，是产生与开发有关的错误的一个很大的诱因。
std::lock的使用方法
tillmanSkate的博客
08-23 5279
假设有两个mutex（m1、m2），一个线程先锁住m1再锁住m2，另一个线程先锁住m2,再锁住m1，就有可能会出现死锁。std::lock内部使用了死锁避免的算法，可以有效避免死锁。有两种用法： std::lock(m1, m2) std::lock_guard lock1(m1, std::adopt_lock) std::lock_guard lock2(m2, std::adopt
C++11多线程之std::lock
FinixLei的专栏 (https://github.com/FinixLei)
03-14 3454
翻译了cppreference上的std::lock一文。
C++ 并发指南 std::lock
qq_24649627的博客
02-18 1496
C++11 标准为我们提供了两种基本的锁类型，分别如下： std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。 std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。 另外还提供了几个与锁类型相关的 Tag 类，分别如下: std::adopt_lock_t，一个空的标记类，定义如下： struct adopt_lock_t {}; 该类型的常量对象adopt_lock。 adopt_lock 是一个
同一份数据，被多线程操作，加互斥锁保护数据
最新发布
m0_74248505的博客
07-28 161
同一份数据，被多线程操作，加互斥锁保护数据 这是正常的+1 和定时器的-1 ，都在操作这个数据，就容易出现问题，这时候为了保护数据，就可以考虑添加数据锁。在加到20时，起一个定时器，依次减1，20秒内重复，这个定时器就是同一个进程的另一个线程。线程，是进程内部的，一个进程中可已包含多个线程，举个例子不知道准确吗。是一个宏定义，用于静态初始化互斥锁（mutex）的属性。一个程序，依次加1，一直加100，这是一个进程的一个线程。
多线程编程的关键是要保护数据
chenm91的专栏
06-14 557
多线程的程序与单线程相比，主要的特点是“同一份数据可能会被多个线程访问，而每个线程执行的程序代码是有可能被从中间中断的，因此如果处理不好，数据的改变可能不是我们期望的那样。” 为了让数据是按期望的那样被修改，必须保证在多个线程访问这些数据时，一定是某个线程执行的某段代码按预期全部执行完，才让另一个线程执行，这称为线程同步concurrency，也就是对数据的保护机制。同步的方式有很多种，比如对某...
adopt_lock 和 defer_lock 的区别
...
11-30 1961
下面三种方法在同时锁住多个互斥量时，是等价的先同时 lock，再创建 guard先创建 guard, 再同时 lock使用 scoped_lockTypeEffect(s)
iOS多线程加锁
Kaiccy的博客
07-17 515
在iOS中有几种方法来解决多线程访问同一个内存地址的互斥同步问题： 方法一，@synchronized(id anObject),(最简单的方法) 会自动对参数对象加锁，保证临界区内的代码线程安全@synchronized(self) { // 这段代码对其他 @synchronized(self) 都是互斥的 // self 指向同一个对象 }
FreeRTOS互斥
QuatumSheldon的博客
08-11 906
互斥信号量是一个特殊的二值信号量类型，用来控制访问多个任务之间共享的资源。允许使用互斥需要在FreeRTOSConfig.h中配置configUSE_MUTEXES为1。 在一个互斥访问的场景，互斥信号量可以被认为是一个令牌，只有拥有这个令牌的任务才能访问某一资源。因此任务在访问这一资源时，要先取得令牌，才被允许访问资源。而在访问资源完毕后，要将令牌放回到原来的位置，供其他任务或自己获取。 这时候我们可能会有疑惑，这个功能不是与之前介绍的二值信号量相类似吗，这里我要提两点不同.. 互斥信号量在使用完.
多线程技术：线程同步与妥协处理机制解决死锁与数据混乱
常见的线程同步工具包括互斥量（Mutex）、信号量（Semaphore）、条件变量（Condition Variable）和读写锁（Read-Write Lock）。通过这些机制，可以防止多个线程同时访问同一资源，确保数据的一致性，并避免死锁的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值