目录
互斥量概念、用法、死锁演示及解决详解
互斥量(mutex)的基本概念
- 保护共享大数据，操作时，某个线程 用代码把共享数据锁住、操作数据、解锁，其他想操作共享数据的线程必须等待解锁，锁定住，操作，解锁。
- 互斥量是个类对象。
- 理解成一把锁，多个线程尝试用 lock() 成员函数来加锁这把锁头，只有一个线程能锁定成功（成功的标志是lock()函数返回）。
- 如果没锁成功，那么流程阻塞在lock()这里不断的尝试去锁这把锁头。
- 互斥量使用要小心，保护数据不多也不少，少了，没达到保护效果，多了，影响效率。
互斥量的用法
- 引入头文件 #include <mutex>;
lock()， unlock()
- 步骤：先lock(), 操作共享数据，再unlock（）。
- lock()和unlock()要成对使用，有lock必然要有unlock，每调用一次lock()，必然应该调用一次unlock()。
- 不应该也不允许调用1次lock()却调用了2次unlock()，也不允许调用2次lock却调用1次unlock()，这些非对称。
- 数量的调用都会导致代码不稳定甚至崩溃。有lock，忘记unlock的问题，非常难排查。
- 如果lock了，注意退出的地方（如 return）是不是加上了unlock，几个出口几个unlock。
#include <iostream> #include <string> #include <thread> #include <vector> #include <list> #include <mutex> using namespace std; class A{ public: //把收到的消息（玩家命令）加入到一个队列的线程 void inMsgRecvQueue() { for (int i = 1; i < 10000; ++i) { cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl; my_mutex.lock(); msgRecvQueue.push_back(i); //假设这个数字就是玩家发来的命令，加入到消息队列中 my_mutex.unlock(); } } //在这个函数中加锁 bool outMsgMutPro(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{}; for (int i = 1; i < 10000; ++i) { bool ret = outMsgMutPro(command); if (ret) { cout << "outMsgMutPro执行了，取出一个元素" << command << endl; //这里就针对具体的命令具体处理 //... } else { //消息队列为空 cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl; } } cout << "outMsgRecvQueue()执行完毕" << endl; } private: std::list<int> msgRecvQueue; //容器（消息队列），专门代表玩家给我们发来的命令 std::mutex my_mutex; }; int main() { A obja; std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象 std::thread inMsgThread(&A::inMsgRecvQueue, &obja); inMsgThread.join(); outMsgThread.join(); //主线程执行 std::cout << "主线程结束" << std::endl; return 0; }
std::lock_guard类模板
- 为了防止大家忘记unlock()，引入了一个叫std::lock_guard的类模板：你忘记unlock不要紧，我替你unlock()。
- 联想智能指针（unique_ptr<>） : 你忘记释放内存不要紧，我给你释放。
- std::lock_guard 类模板：直接取代lock() 和unlock()；也就是说， 你用了lock_guard之后，再不能使用lock()和unlock()了。
- lock_guard构造函数里执行了mutex::lock()。
- lock_guard析构函数里执行了mutex::unlock()。
- 结合 {} ，可以控制作用的范围（RAII）。
#include <iostream> #include <string> #include <thread> #include <vector> #include <list> #include <mutex> using namespace std; class A{ public: //把收到的消息（玩家命令）加入到一个队列的线程 void inMsgRecvQueue() { for (int i = 1; i < 10000; ++i) { cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl; { std::lock_guard<mutex> mutex_guard_in(my_mutex); msgRecvQueue.push_back(i); //假设这个数字就是玩家发来的命令，加入到消息队列中 } //其他代码... } } //在这个函数中加锁 bool outMsgMutPro(int& command ) { std::lock_guard<mutex> mutex_guard_out(my_mutex); if (!msgRecvQueue.empty()) { //消息队列不为空 command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在 msgRecvQueue.pop_front(); //移除第一个元素，但不返回 return true; } return false; } //把消息从消息队列中取出的线程 void outMsgRecvQueue() { int command{}; for (int i = 1; i < 10000; ++i) { bool ret = outMsgMutPro(command); if (ret) { cout << "outMsgMutPro执行了，取出一个元素" << command << endl; //这里就针对具体的命令具体处理 //... } else { //消息队列为空 cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl; } } cout << "outMsgRecvQueue()执行完毕" << endl; } private: std::list<int> msgRecvQueue; //容器（消息队列），专门代表玩家给我们发来的命令 std::mutex my_mutex; }; int main() { A obja; std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象 std::thread inMsgThread(&A::inMsgRecvQueue, &obja); inMsgThread.join(); outMsgThread.join(); //主线程执行 std::cout << "主线程结束" << std::endl; return 0; }
死锁
- 比如我有两把锁（死锁这个问题 是由至少两个锁头也就是两个互斥量才能产生）：金锁（jinlock） 银锁（yinlock）。
- 两个线程 A,B
- (1) 线程A执行的时候，这个线程先锁金锁，把金锁lock()成功了，然后它去lock银锁。
- 出现了上下文切换
- (2) 线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会lock()成功，线程B要去lock金锁。
- 此时此刻，死锁就产生了。
- (3) 线程A因为拿不到银锁头，流程走不下去（所有后边代码有解锁金锁锁头的但是流程走不下去，所以金锁头解不开）。
- (4) 线程B因为拿不到金锁头，流程走不下去（所有后边代码有解锁银锁锁头的但是流程走不下去，所以银锁头解不开）。
- 大家都晾在这里，你等我，我等你。
死锁演示
#include <iostream> #include <string> #include <thread> #include <vector> #include <list> #include <mutex> using namespace std; class A { public: //把收到的消息（玩家命令）加入到一个队列的线程 void inMsgRecvQueue() { for (int i = 1; i < 10000; ++i) { cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl; my_mutex2.lock(); //其他代码 my_mutex1.lock(); msgRecvQueue.push_back(i); //假设这个数字就是玩家发来的命令，加入到消息队列中 my_mutex1.unlock(); //其他代码 my_mutex2.unlock(); } } //在这个函数中加锁 bool outMsgMutPro(int& command ) { my_mutex1.lock(); //其他代码 my_mutex2.lock(); if (!msgRecvQueue.empty()) { //消息队列不为空 command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在 msgRecvQueue.pop_front(); //移除第一个元素，但不返回 my_mutex2.unlock(); //其他代码 my_mutex1.unlock(); return true; } my_mutex2.unlock(); //其他代码 my_mutex1.unlock(); return false; } //把消息从消息队列中取出的线程 void outMsgRecvQueue() { int command{}; for (int i = 1; i < 10000; ++i) { bool ret = outMsgMutPro(command); if (ret) { cout << "outMsgMutPro执行了，取出一个元素" << command << endl; //这里就针对具体的命令具体处理 //... } else { //消息队列为空 cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl; } } cout << "outMsgRecvQueue()执行完毕" << endl; } private: std::list<int> msgRecvQueue; //容器（消息队列），专门代表玩家给我们发来的命令 std::mutex my_mutex1; std::mutex my_mutex2; }; int main() { A obja; std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象 std::thread inMsgThread(&A::inMsgRecvQueue, &obja); inMsgThread.join(); outMsgThread.join(); //主线程执行 std::cout << "主线程结束" << std::endl; return 0; }
死锁的一般解决方案
- 只要保证这两个互斥量上锁的顺序一致就不会死锁。
std::lock()函数模板
- 用来处理多个互斥量的时候才出场。
- 能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，1个不行）。
- 它不存在这种因为再多个线程中 因为锁的顺序问题导致死锁的风险问题。
- std::lock()：
- 如果互斥量中有一个没锁住，它就在那里等着，等所有互斥量都锁住，它才能往下走（返回）。
- 要么两个互斥量都锁住，要么两个互斥量都没锁住。
- 如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。
class A { public: //把收到的消息（玩家命令）加入到一个队列的线程 void inMsgRecvQueue() { for (int i = 1; i < 10000; ++i) { cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl; std::lock(my_mutex1, my_mutex2); msgRecvQueue.push_back(i); //假设这个数字就是玩家发来的命令，加入到消息队列中 my_mutex1.unlock(); //其他代码 my_mutex2.unlock(); } } //在这个函数中加锁 bool outMsgMutPro(int& command ) { std::lock(my_mutex1, my_mutex2); if (!msgRecvQueue.empty()) { //消息队列不为空 command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在 msgRecvQueue.pop_front(); //移除第一个元素，但不返回 my_mutex2.unlock(); //其他代码 my_mutex1.unlock(); return true; } my_mutex2.unlock(); //其他代码 my_mutex1.unlock(); return false; } //把消息从消息队列中取出的线程 void outMsgRecvQueue() { int command{}; for (int i = 1; i < 10000; ++i) { bool ret = outMsgMutPro(command); if (ret) { cout << "outMsgMutPro执行了，取出一个元素" << command << endl; //这里就针对具体的命令具体处理 //... } else { //消息队列为空 cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl; } } cout << "outMsgRecvQueue()执行完毕" << endl; } private: std::list<int> msgRecvQueue; //容器（消息队列），专门代表玩家给我们发来的命令 std::mutex my_mutex1; std::mutex my_mutex2; };
std::lock_guard的std::adopt_lock参数
- std::adopt_lock是个结构体对象，起一个标记作用：作用就是表示这个互斥量已经lock()，不需要再std::lock_guard<std::mutext>构造函数里 再面对对象进行再次lock()了。
class A { public: //把收到的消息（玩家命令）加入到一个队列的线程 void inMsgRecvQueue() { for (int i = 1; i < 10000; ++i) { cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl; std::lock(my_mutex1, my_mutex2); std::lock_guard<mutex> in_mutex_guard1(my_mutex1, std::adopt_lock); std::lock_guard<mutex> in_mutex_guard2(my_mutex2, std::adopt_lock); msgRecvQueue.push_back(i); //假设这个数字就是玩家发来的命令，加入到消息队列中 //其他代码 } } //在这个函数中加锁 bool outMsgMutPro(int& command ) { std::lock(my_mutex1, my_mutex2); std::lock_guard<mutex> out_mutex_guard1(my_mutex1, std::adopt_lock); std::lock_guard<mutex> out_mutex_guard2(my_mutex2, std::adopt_lock); if (!msgRecvQueue.empty()) { //消息队列不为空 command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在 msgRecvQueue.pop_front(); //移除第一个元素，但不返回 return true; } return false; } //把消息从消息队列中取出的线程 void outMsgRecvQueue() { int command{}; for (int i = 1; i < 10000; ++i) { bool ret = outMsgMutPro(command); if (ret) { cout << "outMsgMutPro执行了，取出一个元素" << command << endl; //这里就针对具体的命令具体处理 //... } else { //消息队列为空 cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl; } } cout << "outMsgRecvQueue()执行完毕" << endl; } private: std::list<int> msgRecvQueue; //容器（消息队列），专门代表玩家给我们发来的命令 std::mutex my_mutex1; std::mutex my_mutex2; };
- std::lock()：一次锁定多个互斥量，谨慎使用（建议一个一个锁）。
扫一扫
3278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
