您的位置:首页 > 其它

多线程04:互斥量和死锁

2022-05-12 12:11 246 查看 https://www.cnblogs.com/d-book

📕互斥量和死锁

一、数据共享问题

首先,我们看看多线程的执行顺序:

void TextThread() {
cout << "我是线程:" << this_thread::get_id() << endl;
//线程内操作代码
cout << "线程" << this_thread::get_id() << "操作结束" << endl;
}

int main()
{
vector<thread> threadVec;
for (int i = 0; i < 5; ++i) {
threadVec.push_back(thread(TextThread));
}
for (int i = 0; i < 5; ++i) {
threadVec[i].join();
}
return 0;
}

  • 把thread对象放入到容器中管理,看起来像个thread对象数组,对一次创建大量的线程并对大量线程进行管理有好处;
  • 多个线程执行顺序是乱的,跟操作系统内部对线程的运行调度机制有关;

然而上述的线程中并没有涉及到线程之间的通信问题,如果涉及多个线程操作同一堆数据,会怎么样呢?(学过操作系统都知道,这就是数据共享问题)

  1. 如果是线程只读数据,是安全稳定的,不会存在问题;
  2. 如果是有读有写:①不加处理就会执行出错,如对同一个数据同时读和写,比如简单的一个i,底层是三四条汇编代码,运行过程中(还没有执行完i操作)线程就被调度了,而其他线程又用这个i值,又++i,导致值错乱!;②最简单的防止崩溃方法**:读的时候不能写,写的时候不能读。**

二、互斥量

2.1 互斥量的基本概念

  • c++中互斥量就是个类对象,可以理解为一把锁,多个线程尝试用lock()成员函数来加锁,只有一个线程能锁定成功,如果没有锁成功,那么流程将卡在lock()这里不断尝试去锁定。
  • 互斥量使用要小心,保护数据不要多也不要少,少了达不到效果,多了影响效率。

2.2 互斥量的用法

头文件包含

#include <mutex>

最基础用法

①lock()、unlock()

  • 步骤:1.lock(); 2.操作共享数据;3.unlock();

  • lock()和unlock()要成对使用,注意这种情况:

    //拿取数据的函数
    bool outMsgPro(int& command) {
    
    myMutex.lock();
    if (!msgRecvQueue.empty()) {//非空就进行操作
    int command = msgRecvQueue.front();
    msgRecvQueue.pop();
    //因为进入这里也会return了,一定要unlock();
    myMutex.unlock();
    return true;
    }
    myMutex.unlock();
    //其他操作代码
    return false;
    }

高级一点的写法

②lock_guard类模板

  • lock_guard<mutex> myGuard(myMutex)
    直接取代了
    myMutex.lock()
    myMutex.unlock()
    ;
  • lock_guard构造函数执行了mutexlock();在出作用域,调用析构函数时,执行mutexunlock()
  • 可以加上
    {}
    ,约束lock_guard的作用域;
//拿取数据的函数
bool outMsgPro(int& command) {

{
std::lock_guard<std::mutex> myGuard(myMutex);
if (!msgRecvQueue.empty()) {//非空就进行操作
int command = msgRecvQueue.front();
msgRecvQueue.pop();
return true;
}
}
//其他操作代码
return false;
}

三、死锁

3.1 死锁演示

产生死锁的条件:至少有两个互斥量,多个线程同时需要这两个互斥量,最终形成闭环。比如:

    1. 线程A执行时,这个线程先锁mutex1,并且锁成功了,然后去锁mutex2的时候,出现了上下文切换。
    1. 线程B执行,这个线程先锁mutex2,因为mutex2没有被锁,即mutex2可以被锁成功,然后线程B要去锁mutex1.
    1. 此时,死锁产生了,A锁着mutex1,需要锁mutex2,B锁着mutex2,需要锁mutex1,形成闭环,没法继续运行。

3.2 死锁解决方案

只要保证多个互斥量上锁的顺序一样就不会造成死锁!

3.3 std::lock()函数模板

  • std::lock(mutex1,mutex2……)
    :一次锁定多个互斥量(一般这种情况很少),用于处理多个互斥量。但是锁要单独解开
    mutex1.unlock()
    ,
    mutex2.unlock()
    都要自己写
  • 该函数:如果互斥量中一个都没锁住,它就等着,等所有互斥量都锁住,才能继续执行。如果有一个没锁住,就会把已经锁住的释放掉(即要么互斥量都锁住,要么都没锁住,自动防止死锁)

3.4 stdlock_guard和stdadopt_lock参数

  • std::lock(mutex1,mutex2);
    lock_guard<mutex> myGuard1(mutex1, adopt_lock);
    lock_guard<mutex> myGuard2(mutex2, adopt_lock);

    用lock_guard构造mutex1、mutex2锁的对象,加入adopt_lock后,在调用lock_guard的构造函数时,不再进行lock(); 但是在出了对象的作用域后,还是会调用unlock()释放锁! 解决了lock多个锁后需要自己每个释放的问题。

  • std::adopt_lock
    为结构体对象,起一个标记作用,表示这个互斥量已经lock(),不需要再lock()操作。

整个示例代码:

class A
{
public:
//拿取数据的函数
bool outMsgPro(int& command) {

lock(mutex1, mutex2);
lock_guard<mutex> myGuard1(mutex1, adopt_lock);
lock_guard<mutex> myGuard2(mutex2, adopt_lock);
//②lock_guard<mutex> myGuard1(mutex1); lock_guard<mutex> myGuard2(mutex2);
//①mutex1.lock(); mutex2.lock();
if (!msgRecvQueue.empty()) {//非空就进行操作
command = msgRecvQueue.front();
msgRecvQueue.pop();
//因为进入这里也会return了,一定要unlock();
//mutex1.unlock(); mutex2.unlock();

return true;
}
//mutex1.unlock(); mutex2.unlock();
return false; //return自动释放锁
}
//写入数据函数;
void inMsgPro() {

for (int i = 0; i < 100; ++i) {
cout << "inMsgPro()执行,插入元素" << i << endl;

lock(mutex1, mutex2);
lock_guard<mutex> myGuard1(mutex1, adopt_lock);
lock_guard<mutex> myGuard2(mutex2, adopt_lock);
//②lock_guard<mutex> myGuard1(mutex1); lock_guard<mutex> myGuard2(mutex2);
//①mutex1.lock(); mutex2.lock();
msgRecvQueue.push(i);
//mutex1.unlock(); mutex2.unlock();
}
}
//测试拿出数据函数
void Test() {
int data;
for (int i = 0; i < 100; ++i) {
if (outMsgPro(data)) cout << data << " ";
else cout << "没有数据" << " ";
}
}
private:
queue<int> msgRecvQueue;
mutex mutex1;
mutex mutex2;
};

int main() {
A a;
thread myInMsgObj(&A::inMsgPro, &a);//必须要传入地址,说明是同一个元素
thread myOutMsgObj(&A::Test, &a);
myInMsgObj.join();
myOutMsgObj.join();
return 0;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: