📕互斥量和死锁

一、数据共享问题

首先，我们看看多线程的执行顺序：

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 死锁演示

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

• 线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换。
• 线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
• 此时，死锁产生了，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;
}