C++11并发与多线程笔记（5）互斥量概念、用法、死锁演示及解决详解

最新推荐文章于 2022-10-13 09:29:47 发布
最新推荐文章于 2022-10-13 09:29:47 发布
阅读量274 收藏 1
点赞数 1
分类专栏： C++多线程 文章标签： c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/badmanWang/article/details/121089893
版权

文章目录

1、互斥量的基本概念

​ 当对共享数据进行操作时，为了防止线程冲突，我们应该使某个线程用代码把共享数据锁住，然后操作数据，最后解锁；其他线程想操作共享数据的线程必须等待解锁，锁定住，操作，解锁。这就引出了一个名词概念：互斥量。

**互斥量(mutex)基本概念：**互斥量是个类对象，理解成一把锁，多个线程尝试用互斥量这个类对象的成员函数lock()来加锁这把锁头。只有一个线程能锁定成功（成功的标志是lock()函数返回），如果没锁成功，那么流程卡在lock()这里不断不断尝试去锁这把锁头。

  • 互斥量使用要小心，保护数据不多也不少，少了，没达到保护效果，多了，影响效率。

2、互斥量的用法

2.1 lock()，unlock()

  • 步骤：先lock()，然后操作共享数据，最后unlock()。
  • lock()和unlock()要成对使用，有lock()必然要有unlock()，每调用一次lock()，必然应该调用一次unlock()。
  • 不应该也不允许调用1次lock()却调用了2次unlcok()，也不允许调用2次lock()却只调用了1次unlcok()，这些非对称数量的调用都会导致代码不稳定，甚至崩溃。

示例代码：

#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++)
		{
			my_mutex.lock();
			cout << "inMsgRecvQueue()执行，插入一个元素：" << i << endl;
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
		}
		return;
	}

	bool outMsgLULProc(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 = 0;

		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}

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

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}
  • 注意：有lock()，忘记unlock()的问题，非常难排查。
  • 为了防止大家忘记unlock()，引入了一个叫std::lock_guard的类模板——忘记unlock()不要紧，我替你unlock()。

2.2 std::lock_guard

std::lock_guard：类模板，直接取代lock()和unlock()

  • 用了lock_guard之后，再也不能使用lock()和unlock()。
  • lock_guard构造函数里执行了mutex::lock()。
  • lock_guard析构函数里执行了mutex::unlock()。
  • 当使用lock_guard时，如果想要提前解锁，可以在为执行的代码部分添加{}，则代码块内的变量的生命周期和作用域将被限制在该代码块内，即lock_guard类变量在出代码块时将会执行析构。

示例代码：

#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;

			{
				std::lock_guard<std::mutex> sbguard(my_mutex);
				msgRecvQueue.push_back(i);
			}

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::lock_guard<std::mutex> sbguard(my_mutex);
		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)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}

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

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

3、死锁

  • 死锁这个问题，至少两个锁头也就是两个互斥量才能产生。
  • 死锁就是资源访问冲突，互不相让，形成死循环。

3.1 死锁演示

#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;
             //先锁1后锁2
			my_mutex1.lock();	//实际工程中这两个锁头不一定挨着，可能他们需要保护不同的数据共享块；
			my_mutex2.lock();
			msgRecvQueue.push_back(i);
			my_mutex2.lock();
			my_mutex1.unlock();

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
         //先锁2后锁1
		my_mutex2.lock();
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			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;
			}
		}
	}

private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex1;					//创建了一个互斥量
	mutex my_mutex2;					//创建了另一个互斥量

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

上述线程函数inMsgRecvQueue()中是先锁1后锁2，而线程函数outMsgRecvQueue中则是先锁2后锁1，这就造成了死锁，当程序运行时就会出现一致互相等待的状况。

3.2 死锁的一般解决方案

  • 只要保证这两个互斥量上锁的顺序一致就不会死锁。

示例代码：

#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;

			std::lock_guard <mutex> sbguard1(my_mutex1);
			std::lock_guard <mutex> sbguard2(my_mutex2);
			//my_mutex1.lock();	//实际工程中这两个锁头不一定挨着，可能他们需要保护不同的数据共享块；
			//my_mutex2.lock();
			msgRecvQueue.push_back(i);
			//my_mutex2.unlock();
			//my_mutex1.unlock();

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::lock_guard <mutex> sbguard1(my_mutex1);
		std::lock_guard <mutex> sbguard2(my_mutex2);
		//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 = 0;

		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}

private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex1;					//创建了一个互斥量
	mutex my_mutex2;					//创建了另一个互斥量

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

3.3 std::lock()函数模板

std::lock()

  • 一次锁住两个或者两个以上的互斥量（至少两个，多了不限，一个不行）。
  • 它不存在这种因为在多个线程中，因为锁的顺序问题导致死锁的风险问题。
  • 要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没锁成功，则它立即把已经锁住的解锁。
  • 用来处理多个互斥量的时候才出场。

示例代码：

#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;

			std::lock(my_mutex1, my_mutex2);		//相当于每个互斥量都调用了.lock()

			msgRecvQueue.push_back(i);

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

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::lock(my_mutex1, my_mutex2);		//相当于每个互斥量都调用了.lock()
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			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;
			}
		}
	}

private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex1;					//创建了一个互斥量
	mutex my_mutex2;					//创建了另一个互斥量

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

3.4 std::lock_guard的std::adopt_lock参数

  • 一定要在std::lock后再用std::lock_guard，std::adopt_lock会略过lock()步骤，在结束析构的时候自动执行unlock()。
  • std::adopt_lock是个结构体对象，起一个标记作用。
  • std::adopt_lock就是表示这个互斥量已经执行了lock()，不需要在std::lock_guard<std::mutex>里面对对象再次进行lock()了。

示例代码：

#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;

			std::lock(my_mutex1, my_mutex2);		//相当于每个互斥量都调用了.lock()

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

			msgRecvQueue.push_back(i);

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::lock(my_mutex1, my_mutex2);		//相当于每个互斥量都调用了.lock()

		std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);
		std::lock_guard<std::mutex> sbguard2(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)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}

private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	mutex my_mutex1;					//创建了一个互斥量
	mutex my_mutex2;					//创建了另一个互斥量

};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();

	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

3.5 总结

  • std::lock：一次锁定多个互斥量，谨慎使用。
  • 实际工程中每个互斥量保护着不同的代码段，因此使用一次锁定的情况很少用，建议一个一个锁。

注：本人学习c++多线程视频地址：C++多线程学习地址

Jack丶Wang
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 多线程死锁详解及简单实例
08-31
主要介绍了java 多线程死锁详解及简单实例的相关资料,需要的朋友可以参考下
c++ builder 使用windows 互斥量 (Mutex)
weixin_39926429的博客
04-05 1016
//在以前的文章中介绍了c++ builder 临界区，使用于同一进程，也就是一个应用程序中。 //那么，mutex使用于跨进程场景，即不同的应用程序需要独占某种资源的场景。 //本文种独占的资源是屏幕，当然也可以是文件，其它硬件等。 //本文在c++ builder 10.3调试通过。 //以下两个程序，编译后，找到exe文件,运行一个程序后，立刻运行另一个程序。 //可以观察到，后运行的程序要等待先运行的程序打印完毕后，才在屏幕上打印。 //程序A: #include <stdio.
C++线程之使用互斥量
Stay hungry, Stay foolish
10-13 442
保护共享数据结构的最基本的方式，就是使用C++标准库提供的互斥量。访问共享数据前，将数据锁住，在访问结束后，再将数据解锁。线程库需要保证，当线程使用互斥量锁住共享数据时，其他的线程都必须等到之前那个线程对数据进行解锁后，才能进行访问数据。互斥量是C++保护数据最通用的机制，但也需要编排代码来保护数据的正确性，并避免接口间的条件竞争也非常重要。不过，互斥量也会造成死锁，或对数据保护的太多(或太少)。
C++多线程通信：互斥与同步
WHEgqing的专栏
03-31 611
在一个多线程的应用程序中，所有线程共享进程资源，协同工作。所以，线程之间的通信是编写多线程应用的必不可少的环节。线程之间的通信包括互斥、同步等，它是多线程设计中最难控制的部分，也是关键部分。
C++新特性（六）多线程（2）线程中互斥量的使用，mutex对象使用，lock_guard类模板，死锁的解决
weixin_42445051的博客
02-15 677
一，创建多个线程 前面学习了怎么使用thread类创建一个线程C++新特性（六）多线程（1）线程启动、结束，创建线程、join，detach，线程传参详解 ，在实际应用中，我们可以创建多个线程 void TextThread() { cout << "我是线程" << this_thread::get_id() << endl; /* … */ cout << "线程" << this_thread::get_id
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
本书全面解析了Java并发编程的核心概念、原理和实践，帮助读者深入理解多线程并发编程的精髓，提升编程能力和系统性能。 书中首先介绍了并发编程的基础知识，包括线程的基本概念、线程的生命周期、线程安全等问题。...
python 多线程死锁问题的解决方案
01-21
就是当多线程访问多个锁的时候，不同的锁被不同的线程持有，它们都在等待其他线程释放出锁来，于是便陷入了永久等待。比如A线程持有1号锁，等待2号锁，B线程持有2号锁等待1号锁，那么它们永远也等不到执行的那天，...
c++多线程死锁检测
01-03
一个简单有效的即时检测线程死锁的方法（附c++源代码） 原文链接：https://blog.csdn.net/liaozhilong88/article/details/80354414 原链接是windows下实现，这份代码以pthread简单实现跨平台 感谢原博主分享
C11:mutex和lock_guard的使用.
热门推荐
闭上左眼看世界的博客
04-05 1万+
在C++11中,引入了有关线程的一系列库.且都在std命名空间内.下面演示一个使用线程的例子.非常的简单.引入了thread和mutex头文件. #include &lt;iostream&gt; #include &lt;thread&gt; #include &lt;mutex&gt; using namespace std; int g_i = 0; mutex g_mutex; voi...
关于lock_guard使用细节
尹平华
12-09 566
c++11之后新增的了lock_guard函数，使用起来比较方便，但难免会遇到很多坑，接下来，我就简单说一下： 1：如何自己实现一个mutex类的话，需要使用lock函数和unlock函数，而且名字要一模一样 2: 如果配合lambda表达式使用，注意随时解锁，难免会发送死锁。这是很难找到的bug ...
多线程，lock_guard和unique_lock的使用
qilimi1053620912的博客
03-22 852
    ~~~~    之前使用锁的时候，要自动释放，就自己写了一个类，通过构造和析构函数自动释放锁，后来发现了std::lock_guard，然后就没有使用自己写的自动释放类了。     ~~~~    今天又发现了std::unique...
std:lock_guard 不能用在 condition_variable wait中
一朝柯梦的博客
06-30 1124
1， std:lock_guard、unique_lock、condition_variable 一般使用实例 #include <condition_variable> #include <mutex> #include <future> #include <iostream> bool readyFlag; std::mutex read...
std::lock_guard对整个函数加锁访问
shujianlove0的博客
11-27 951
std::lock_guard&lt;std::mutex&gt; lock(mutex_); 性能优化是最小使用原则，那么将需要使用的代码块单独拿出来作为函数 mutex_将会自动release 当超出作用范围的时候。 lock_guard 对象的拷贝构造和移动构造(move construction)均被禁用，因此 lock_guard 对象不可被拷贝构造或移动构造。 void safe_in...
java多线程死锁bug解决
03-21
解决多线程死锁问题的方法主要有以下几种： 1. 避免嵌套锁：尽量避免在一个锁内部获取另一个锁，这样可以减少死锁的可能性。 2. 按顺序获取锁：如果多个线程需要获取多个锁，可以约定一个获取锁的顺序，按照相同的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值