多线程04:互斥量和死锁
????互斥量和死锁
一、数据共享问题
首先,我们看看多线程的执行顺序:
网站设计、成都网站建设的开发,更需要了解用户,从用户角度来建设网站,获得较好的用户体验。创新互联多年互联网经验,见的多,沟通容易、能帮助客户提出的运营建议。作为成都一家网络公司,打造的就是网站建设产品直销的概念。选择创新互联,不只是建站,我们把建站作为产品,不断的更新、完善,让每位来访用户感受到浩方产品的价值服务。
void TextThread() {
cout << "我是线程:" << this_thread::get_id() << endl;
//线程内操作代码
cout << "线程" << this_thread::get_id() << "操作结束" << endl;
}
int main()
{
vector 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
最基础用法
①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
直接取代了myGuard(myMutex) myMutex.lock()
和myMutex.unlock()
;- lock_guard构造函数执行了mutex::lock();在出作用域,调用析构函数时,执行mutex::unlock()
- 可以加上
{}
,约束lock_guard的作用域;
//拿取数据的函数
bool outMsgPro(int& command) {
{
std::lock_guard 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
myGuard1(mutex1, adopt_lock); lock_guard 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 myGuard1(mutex1, adopt_lock);
lock_guard myGuard2(mutex2, adopt_lock);
//②lock_guard myGuard1(mutex1); lock_guard 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 myGuard1(mutex1, adopt_lock);
lock_guard myGuard2(mutex2, adopt_lock);
//②lock_guard myGuard1(mutex1); lock_guard 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 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;
}
当前题目:多线程04:互斥量和死锁
浏览路径:http://scjbc.cn/article/dsoipge.html