C++_800_0605_互斥量死锁问题详解

#include<iostream>
#include<boost/thread/thread.hpp>
#include<mutex>

//保护共享数据，操作时，某个线程用代码把共享数据锁住，操作数据，解锁。
//其他想操作共享数据的线程必须等待解锁

//互斥量
//一：互斥量(mutex)的基本概念
//互斥量是个类对象。理解成一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功（成功的标志是lock()函数返回）
//如果没锁成功，那么流程卡在lock()这里不断的尝试去锁这把锁头；
//互斥量使用要小心，保护数据不多也不少，少了，没达到保护效果，多了，影响效率

//二：互斥量的用法：
//（2.1）lock(), unlock()
//步骤：先lock(),操作共享数据，unlock();
//lock()和unlock()要成对使用，有lock()必然要有unlock,每调用一次lock()，必然应该调用一次unlock();
//不应该也不允许调用1次lock() 却调用了2次unlock(), 也不容许调用2次lock却调用1次unlock(),这些非对称数量的调用，都会导致程序崩溃
//有lock ，忘记unlock的问题，非常难排查;
//为了防止大家忘记unlock(), 引入了一个叫std::lock_guard的类模板，你忘记unlock不要紧，我替你unlock();

//(2.2)std::lock_guard类模板：直接取代lock()和unlock()，也就是说，用了lock_guard之后，就不需要用lock()和unlock()了

class A {
public:
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
std::cout << "inMsgRecvQueue()执行，插入一个元素" << std::endl;

{
std::lock_guard<std::mutex> guard(my_mutex);
//my_mutex.lock();
msgRecvQueue.push_back(i);
//my_mutex.unlock();
}
}
return;
}

bool outMsgLULProc(int& command)
{
std::lock_guard<std::mutex> guard(my_mutex);    //lock_guard构造函数里执行了mutex::lock()
//lock_guard析构函数执行了mutex::unlock()

//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 = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
std::cout << "outMsgRecvQueue()执行，取出一个元素" << command << std::endl;
}
else
{
//消息队列为空
std::cout << "outMsgRecvQueue()执行,但目前消息队列为空" << i << std::endl;
}
}
}

private:
std::list<int> msgRecvQueue; //容器（消息队列）
std::mutex my_mutex; //创建一个互斥量
std::mutex my_mutex2;//创建一个互斥量
};

int main()
{

A myjob;
std::thread myOutMsgObj(&A::outMsgRecvQueue, &myjob); //第二个参数是引用，才能保证线程里用的是同一个对象
std::thread myInMsgObj(&A::inMsgRecvQueue, &myjob);

myInMsgObj.join();
myOutMsgObj.join();

return 0;
}

死锁问题：

#include<iostream>
#include<boost/thread/thread.hpp>
#include<mutex>

//死锁问题
//(3.1)死锁演示
//死锁这个问题，是由至少两个锁头也就是两个互斥量才能产生 金锁，银锁
//两个线程A,B
//（1）线程A执行的时候，这个线程先锁金锁，把金锁lock()成功了，然后它去lock银锁
//出现了上下文切换
//（2）线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会lock()成功，线程B要去lock金锁
//此时此刻，死锁产生了，大家都晾在这里，你等我，我等你

//(3.2)死锁的一般解决方案：
//只要保证这两个互斥量上锁的顺序一致就不会死锁
//（3.3）std::lock()函数模板：用来处理多个互斥量的时候出场
//能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，1个不行）
//它不存在因为多个线程中，因为锁的顺序问题导致死锁的风险问题
//std::lock():如果互斥量中有一个没锁住，它就在那里等着，等所有的互斥量都锁住，它才能往下走
//要么这两个互斥量都锁住，要么这两个互斥量都没锁住。如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。

class A {
public:
void inMsgRecvQueue()
{
for (int i=0;i<10000;i++)
{
std::cout << "inMsgRecvQueue()执行，插入一个元素"<<std::endl;

{
my_mutex.lock();//实际工程这两个锁头不一定挨着，可能他们需要保护不同的数据共享块
my_mutex2.lock();
msgRecvQueue.push_back(i);
my_mutex.unlock();
my_mutex2.unlock();
}
}
return;
}

bool outMsgLULProc(int &command)
{
my_mutex2.lock();
my_mutex.lock();

if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素，但不返回
my_mutex.unlock();
my_mutex2.unlock();
return true;
}

my_mutex.unlock();
my_mutex2.unlock();
return false;
}

//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for(int i = 0; i < 10000;i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
std::cout << "outMsgRecvQueue()执行，取出一个元素" <<command<< std::endl;
}
else
{
//消息队列为空
std::cout<<"outMsgRecvQueue()执行,但目前消息队列为空"<<i<<std::endl;
}
}
}

private:
std::list<int> msgRecvQueue; //容器（消息队列）
std::mutex my_mutex; //创建一个互斥量
std::mutex my_mutex2;//创建一个互斥量
};

int main()
{

A myjob;
std::thread myOutMsgObj(&A::outMsgRecvQueue,&myjob); //第二个参数是引用，才能保证线程里用的是同一个对象
std::thread myInMsgObj(&A::inMsgRecvQueue,&myjob);

myInMsgObj.join();
myOutMsgObj.join();
return 0;
}

上述代码执行后，会出现死锁，解决的方案是：
（1）保证这两个互斥量上锁的顺序一致就不会死锁
（2）std::lock()函数模板：用来处理多个互斥量的时候出场

解决死锁的代码：

#include<iostream>
#include<boost/thread/thread.hpp>
#include<mutex>
//死锁问题
//(3.1)死锁演示
//死锁这个问题，是由至少两个锁头也就是两个互斥量才能产生 金锁，银锁
//两个线程A,B
//（1）线程A执行的时候，这个线程先锁金锁，把金锁lock()成功了，然后它去lock银锁
//出现了上下文切换
//（2）线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会lock()成功，线程B要去lock金锁
//此时此刻，死锁产生了，大家都晾在这里，你等我，我等你

//(3.2)死锁的一般解决方案：
//只要保证这两个互斥量上锁的顺序一致就不会死锁
//（3.3）std::lock()函数模板：用来处理多个互斥量的时候出场
//能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，1个不行）
//它不存在因为多个线程中，因为锁的顺序问题导致死锁的风险问题
//std::lock():如果互斥量中有一个没锁住，它就在那里等着，等所有的互斥量都锁住，它才能往下走
//要么这两个互斥量都锁住，要么这两个互斥量都没锁住。如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。

//(3.4) 为了防止死锁的发生，可以采用std::lock() 但有时会忘记unlock 针对这种问题，采用如下的方式：
//std::lock_guard的std::adopt_lock参数  std::adopt_lock是个结构体对象，起一个标记作用：作用是表示这个互斥量已经lock(),
//不需要在std::lock_guard<std::mutex>构造函数里面对mutex对象进行lock()了；
//总结：std::lock() 一次锁定多个互斥量，谨慎使用（建议一个一个锁，但一个一个锁，注意锁的顺序问题）

class A {
public:
void inMsgRecvQueue()
{
for (int i=0;i<10000;i++)
{
std::cout << "inMsgRecvQueue()执行，插入一个元素"<<std::endl;

{
std::lock(my_mutex,my_mutex2);  //相当于互斥量都调用了 lock()
//因为已经调用了std::lock()了，所以在使用std::lock_guard的时候，不能再锁一次了，
// 所以要有std:;adopt_lock这个是为了unlock()
std::lock_guard<std::mutex> guard1(my_mutex,std::adopt_lock);

std::lock_guard<std::mutex> guard2(my_mutex2, std::adopt_lock);

msgRecvQueue.push_back(i);
}
}
return;
}

bool outMsgLULProc(int &command)
{
std::lock(my_mutex,my_mutex2);

std::lock_guard<std::mutex> guard1(my_mutex,std::adopt_lock);
std::lock_guard<std::mutex> guard2(my_mutex2, std::adopt_lock);

if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素，但不返回
return true;
}
return false;
}

//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for(int i = 0; i < 10000;i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
std::cout << "outMsgRecvQueue()执行，取出一个元素" <<command<< std::endl;
}
else
{
//消息队列为空
std::cout<<"outMsgRecvQueue()执行,但目前消息队列为空"<<i<<std::endl;
}
}
}

private:
std::list<int> msgRecvQueue; //容器（消息队列）
std::mutex my_mutex; //创建一个互斥量
std::mutex my_mutex2;//创建一个互斥量
};

int main()
{

A myjob;
std::thread myOutMsgObj(&A::outMsgRecvQueue,&myjob); //第二个参数是引用，才能保证线程里用的是同一个对象
std::thread myInMsgObj(&A::inMsgRecvQueue,&myjob);

myInMsgObj.join();
myOutMsgObj.join();

return 0;
}