C++详细讲解互斥量与lock_guard类模板及死锁

保护共享数据，操作时，用代码把共享数据锁住、操作数据、解锁

其他想操作共享数据的线程必须等待解锁、锁定住、操作、解锁

互斥量的基本概念

• 互斥量是个类对象，理解成一把锁，多个线程尝试使用lock()成员函数来枷锁这个锁，是有一个线程可以锁成功，成功的标志是返回
• 如果没有锁成功，那么流程卡在lock这里不断尝试去锁

互斥量的使用

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A {
public:
  //把收到的消息(玩家命令)  入到一个队列的线程
  void inMsgRecvQueue()
  {
      for (int i = 0; i < 1000; i++) {
              cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
              my_mutex.lock();
              msgRecvQueue.push_back(i);//假设这个数字就是收到的命令
              my_mutex.unlock();
      }
  }
  int mesg_lock_func(void)
  {
      int ret = 0;
      my_mutex.lock();
      if (!msgRecvQueue.empty()) {
           ret = msgRecvQueue.front();//读头部元素
          msgRecvQueue.pop_front();//移除头部元素
          //处理数据
          //cout << "接收到命令，处理命令" << ret << endl;
      }
      my_mutex.unlock();
      return ret;
  }
  void outMsgRecvQueue()
  {
      int cmd = 0;
      for (int i = 0; i < 1000; i++)
      {
          cmd = mesg_lock_func();
          if (cmd) {
              cout << "接收到命令，处理命令" << cmd << endl;
          }
          else
          {
              cout << "outMsgRecvQueue执行，但目前消息队列为空" << i << endl;
          }
      }
  }
private:
  list<int> msgRecvQueue; //容器，专门用于代表玩家给咱们发送过来的命令
  mutex my_mutex;
};

lock_guard类模板

为什么此处只有一句 lock_guard sbguard(my_mutex);函数即可 不出问题

lock_guard原理:

lock_guard创建 sbguard(my_mutex);对象，会有构造函数，在构造函数中进行了my_mutex.lock

在函数执行结束后，局部对象会释放，执行析构函数的时候会执行my_mutex.unlock

    int mesg_lock_func(void)
  {
      int ret = 0;
      //my_mutex.lock();
      lock_guard<mutex> sbguard(my_mutex);
      if (!msgRecvQueue.empty()) {
           ret = msgRecvQueue.front();//读头部元素
          msgRecvQueue.pop_front();//移除头部元素
          //处理数据
          //cout << "接收到命令，处理命令" << ret << endl;
      }
      //my_mutex.unlock();
      return ret;
  }

死锁

死锁的条件:

两个线程同时 锁住 两把锁， A线程先锁 锁1，后锁 锁2；B线程先锁 锁2，后锁 锁1，就会发生死锁

class A {
public:
  //把收到的消息(玩家命令)  入到一个队列的线程
  void inMsgRecvQueue()
  {
      for (int i = 0; i < 10000; i++) {
              cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
              my_mutex1.lock();
              my_mutex2.lock();
              msgRecvQueue.push_back(i);//假设这个数字就是收到的命令
              my_mutex2.unlock();
              my_mutex1.unlock();
      }
  }
  int mesg_lock_func(void)
  {
      int ret = 0;
      my_mutex2.lock();
      my_mutex1.lock();
      //lock_guard<mutex> sbguard(my_mutex);
      if (!msgRecvQueue.empty()) {
           ret = msgRecvQueue.front();//读头部元素
          msgRecvQueue.pop_front();//移除头部元素
          //处理数据
          //cout << "接收到命令，处理命令" << ret << endl;
      }
      my_mutex1.unlock();
      my_mutex2.unlock();
      return ret;
  }
  void outMsgRecvQueue()
  {
      int cmd = 0;
      for (int i = 0; i < 10000; i++)
      {
          cmd = mesg_lock_func();
          if (cmd) {
              cout << "接收到命令，处理命令" << cmd << endl;
          }
          else
          {
              cout << "outMsgRecvQueue执行，但目前消息队列为空" << i << endl;
          }
      }
  }
private:
  list<int> msgRecvQueue; //容器，专门用于代表玩家给咱们发送过来的命令
  mutex my_mutex1;
  mutex my_mutex2;
};

防止死锁的条件:

两个锁的 锁的顺序必须相同

lock(mutex1, mutex2);

lock_guard sbguard1(my_mutex1,adopt_lock);’

lock与lock_guard的使用

    int mesg_lock_func(void)
  {
      int ret = 0;
      lock(my_mutex1, my_mutex2);
      lock_guard<mutex> sbguard1(my_mutex1, adopt_lock);
      lock_guard<mutex> sbguard2(my_mutex2, adopt_lock);
      //lock_guard<mutex> sbguard(my_mutex);
      if (!msgRecvQueue.empty()) {
           ret = msgRecvQueue.front();//读头部元素
          msgRecvQueue.pop_front();//移除头部元素
          //处理数据
          //cout << "接收到命令，处理命令" << ret << endl;
      }
      return ret;
  }

关于C++详细讲解互斥量与lock_guard类模板及死锁的文章就介绍至此，更多相关C++互斥量内容请搜索编程宝库以前的文章，希望以后支持编程宝库！

 vector基本概念功能:vector数据结构和数组非常相似，也称为单端数组vector与普通数组区别:不同之处在于数组是静态空间，而vector可以动态扩展动态扩展:并不是在原空间之后继续接新空 ...