多线程04：互斥量和死锁
📕互斥量和死锁
一、数据共享问题
首先，我们看看多线程的执行顺序：
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对象数组，对一次创建大量的线程并对大量线程进行管理有好处；
- 多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关；
然而上述的线程中并没有涉及到线程之间的通信问题，如果涉及多个线程操作同一堆数据，会怎么样呢？（学过操作系统都知道，这就是数据共享问题）
- 如果是线程只读数据，是安全稳定的，不会存在问题；
- 如果是有读有写：①不加处理就会执行出错，如对同一个数据同时读和写，比如简单的一个++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构造函数执行了mutex::lock();在出作用域，调用析构函数时，执行mutex::unlock()
- 可以加上
{}，约束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. 线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换。
- b. 线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
- c. 此时，死锁产生了，A锁着mutex1，需要锁mutex2，B锁着mutex2，需要锁mutex1，形成闭环，没法继续运行。
3.2 死锁解决方案
只要保证多个互斥量上锁的顺序一样就不会造成死锁！
3.3 std::lock()函数模板
std::lock(mutex1,mutex2……)：一次锁定多个互斥量（一般这种情况很少），用于处理多个互斥量。但是锁要单独解开mutex1.unlock(),mutex2.unlock()都要自己写- 该函数：如果互斥量中一个都没锁住，它就等着，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（即要么互斥量都锁住，要么都没锁住，自动防止死锁）
3.4 std::lock_guard和std::adopt_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;
}
