C++并发与多线程(5)-互斥锁

互斥量概念、用法、死锁演示及解决详解

1、互斥量(mutex)的基本概念

概念:

互斥量:类对象,理解成一把锁,多个线程尝试用lock()成员函数来加锁,只有一个线程能锁定成功(成功的标志是Lock()函数返回),如果没锁成功,那么流程将卡在lock()这里不断的尝试去锁。

注意:互斥量使用要小心,保护数据不能多也不能少,少了,没达到保护效果,多了,影响效率。

2、互斥量用法

步骤:

先lock()加锁,再操作共享数据,最后别忘记unlock()解锁

lock()和unlock()要成对使用,有一次lock()必然要有一次unlock();
不允许也不应该对lock()和unlock()进行非对称数量的调用,否者导致程序不稳定甚至崩溃。

互斥锁的创建:

std::mutex my_mutex;

案例:

#include <iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>

using namespace std;
class A {
public:

	//把收到的消息(玩家命令)入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
			my_mutex.lock();
			// 假设这个数字i就是我收到的命令,我直接弄到消息队列中来;
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		my_mutex.lock();
		// 消息不为空
		if (!msgRecvQueue.empty())
		{
			// 返回第一个元素,但不检查元素是否存在;
			int command = msgRecvQueue.front();
			// 移除第一个元素,但不返回;
			msgRecvQueue.pop_front();
			// if (true)对应一个解锁
			my_mutex.unlock(); 
			return true;
		}
		// if(false)对应一个解锁
		my_mutex.unlock();
		return false;
	}

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

private:
	std::list<int>msgRecvQueue;//共享数据 容器(消息队列),专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量

};
int main(int argc, char* argv[])
{

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

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

	return 0;
}

注意:如果在使用lock()时,程序中存在 if…else、异常处理等情况,必须在每个分支出口处,使用unlock()解锁。

3、std::lock_guard()类模板

上述情况在,可能偶尔忘记unlock(),这就引入了lock_guard()的类模板。也就是说即使忘记使用unlock(),系统也直接调用unlock()。

lock_guard()可以直接取代lock()、unlock(),用了lock_guard()之后,就不能再调用lock()、unlock(),其封装原理:

1、lock_guard()构造函数里执行了mutex::lock()函数;
2、析构函数里执行了mutex::unlock()函数。

#include <iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>

using namespace std;
class A {
public:

	//把收到的消息(玩家命令)入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
			my_mutex.lock();
			// 假设这个数字i就是我收到的命令,我直接弄到消息队列中来;
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		// 模板
		std::lock_guard<std::mutex> mutexGuard(my_mutex); 
		// 消息不为空
		if (!msgRecvQueue.empty())
		{
			// 返回第一个元素,但不检查元素是否存在;
			int 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)
			{
				cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
				//可以考虑数据的处理了……
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}

private:
	std::list<int>msgRecvQueue;//容器(消息队列),专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量

};
int main(int argc, char* argv[])
{

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

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

	return 0;
}

但是,使用lock_guard()只在某个函数结束也就是return时才执行析构,但是这个函数中还有其它代码,也锁住吗?显然这样做不够灵活,所以这里提出一个小技巧,在要进行添加互斥量的代码上使用大括号 {…} 进行作用域限制:

        for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
			{
				std::lock_guard<std::mutex> mutexGuard1(my_mutex);
				//my_mutex.lock();
				// 假设这个数字i就是我收到的命令,我直接弄到消息队列中来;
				msgRecvQueue.push_back(i);
				//my_mutex.unlock();
			}
			// 。。。
			// 其他代码
			
		}

这样,互斥量只作用于{…}中的代码,也就是msgRecvQueue这块内存了。

4、死锁

4.1、死锁现象

死锁现象:C++中,假设有两把锁(死锁产生的前提条件是有至少两把锁头,即两个互斥量)金锁(JinLock)、银锁(YinLock)假设有两个线程A,B。

1、线程A执行的时候,这个线程先锁金锁,把金锁Lock()成功了,然后他去尝试lock银锁;
2、此时,却去进行另外一个线程(切线程);
3、线程B执行了,这个线程先锁银锁,因为银锁还没有被锁,所以银锁会被lock成功,然后线程B要去lock金锁;
4、这时死锁现象产生了:线程A由于拿不到银锁,流程走不下去(虽然后边代码有解锁金锁的但是流程走不下去,所以金锁解不开);线程B由于拿不到金锁,流程走不下去(虽然后边代码有解锁银锁的但是流程走不下去,所以银锁解不开)。

#include <iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>

using namespace std;
class A {
public:
	//把收到的消息(玩家命令)入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
			my_mutex1.lock();//实际工程中这两个锁头代码不一定挨着,可能她们需要保护不同的数据共享块
			my_mutex2.lock();

			msgRecvQueue.push_back(i);//假设这个数字i就是我收到的命令,我直接弄到消息队列中来;
			
			my_mutex2.unlock();
			my_mutex1.unlock();

		}
		return;
	}
	
	bool outMsgLULProc(int &command)
	{	
		//std::lock_guard<std::mutex>sbguard(my_mutex1);//sbguard时随便起的对象名
		my_mutex2.lock();
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
			int command = msgRecvQueue.front();//返回第一个元素,但不检查元素是否存在;
			msgRecvQueue.pop_front();//移除第一个元素,但不返回;
			my_mutex1.unlock();
			my_mutex2.unlock();

			return true;
		}
		my_mutex1.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)
			{
				cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
			//可以考虑数据的处理了……
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	std::list<int>msgRecvQueue;//容器(消息队列),专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了另外一个互斥量

};
int main(int argc, char* argv[])
{

	A myobja;
	thread myOutMsgObj(&A::outMsgRecvQueue, ref(myobja));
	thread myInMsgObj(&A::inMsgRecvQueue, ref(myobja));

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

4.2、死锁的解决方案

只要保证这两个互斥量上锁的顺序一致就不会造成死锁。
在这里插入图片描述

5、std::lock()函数模板

一次同时锁住两个或者是两个以上的互斥量(至少两个,多了不限),它不存在这种因为在多个线程中因为上锁顺序问题导致的死锁风险的问题。主要是处理多个互斥量。
实现原理:

1、如果互斥量中有一个没锁住,它就在那等着,等所有互斥量都锁住,他才能往下走;
2、要么两个互斥量同时锁住,要么两个互斥量都没锁住。一旦有一个没锁住,std::lock()将立即把已经锁住的互斥量释放(解锁),等待两个同时可以锁住的时机。

	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;
            // 相当于每个互斥量都调用了lock()
			std::lock(my_mutex1, my_mutex2);
			msgRecvQueue.push_back(i);

			my_mutex2.unlock();
			my_mutex1.unlock();

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		// 相当于每个互斥量都调用了lock()
		std::lock(my_mutex1, my_mutex2);
		if (!msgRecvQueue.empty())
		{
			int command = msgRecvQueue.front();
			msgRecvQueue.pop_front();
			my_mutex2.unlock();
			my_mutex1.unlock();
			return true;
		}
		my_mutex2.unlock();
		my_mutex1.unlock();
		return false;
	}

有点遗憾的地方在于还需要使用ublock()解锁。

6、std::lock_guard引入std:adopt_lock参数

使用std::lock_guard解决std::lock()还需要unlock()问题:

void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素 " << i << endl;

			std::lock(my_mutex1, my_mutex2);//相当于每个互斥量都调用了lock()
			std::lock_guard<std::mutex>sbguard1(my_mutex1,std::adopt_lock);//sbguard1时随便起的对象名
			std::lock_guard<std::mutex>sbguard2(my_mutex2,std::adopt_lock);//sbguard2时随便起的对象名

			msgRecvQueue.push_back(i);//假设这个数字i就是我收到的命令,我直接弄到消息队列中来;
		}
		return;

在使用std::lock(my_mutex1, my_mutex2)时已经对锁my_mutex1, my_mutex2已经进行了lock(),那么lock_guard时就不需要再lock()了,怎么办呢?引入std:adopt_lock即可。std:adopt_lock是个结构体对象,起一个标记作用,即标记这个互斥量已经lock()了。

std::lock_guard<std::mutex>sbguard1(my_mutex1,std::adopt_lock);

那么,后续就可以利用std::lock_guard对互斥量进行自动析构了。

总结:std::lock()一次锁多个互斥量;谨慎使用(建议一个一个的锁)。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值