C++ 并发与多线程（四）

最新推荐文章于 2023-02-05 17:19:31 发布
最新推荐文章于 2023-02-05 17:19:31 发布
阅读量114 收藏
点赞数
分类专栏： C++并发与多线程 文章标签： 多线程 c++ thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dddgggd/article/details/116376277
版权

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

1.互斥量（mutex）的基本概念

保护共享号数据，某个线程操作时需要把共享数据锁住，然后操作数据，最后解锁。
其他想操作共享数据的线程必须等待解锁，锁定住，操作，解锁。

互斥量：类对象，理解为一把锁，多个线程尝试用lock函数来加锁这个锁头，只有一个线程能锁定成功,如果没有锁成功，则一直卡在lock函数直到有线程锁定成功

互斥量使用要小心，保护多了或少了都不好。

2.互斥量的用法

2.1 lock（）和unlock（）

当不使用lock和unlock时，同时读写绘出错
在这里插入图片描述
当我们加入lock和unlock时

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
		
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			my_mutex.lock();
			msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	
			my_mutex.unlock();
		}
	}


	bool outMsgLULproc(int &command)
	{
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			my_mutex.unlock();
			return true;
		}	
		else
		{
			my_mutex.unlock();
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex;           //创建一个互斥量

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();
	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。

}

就可以同时进行读写操作
在这里插入图片描述

2.2 std::lock_guard类模板

std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock
示例：

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			my_mutex.lock();
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			
			msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	
			my_mutex.unlock();
		}
	}


	bool outMsgLULproc(int &command)
	{
		lock_guard<mutex>sbguard(my_mutex);       //sbguard是对象名
		/*my_mutex.lock();*/
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			/*my_mutex.unlock();*/
			return true;
		}	
		else
		{
			/*my_mutex.unlock();*/
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex;           //创建一个互斥量

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();


	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。有lock忘记unlock的问题非常难排查
	//为了防止忘记unlock（），引入了一个叫std::lock_guard的类模板
	//智能指针(unique_ptr<>)

	//std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock

}

工作原理：lock_guard构造函数里执行了lock函数，析构lock_guard时，执行了unlock函数

3 死锁

3.1 死锁演示

死锁问题的前提条件是：有至少两个锁，即至少两个互斥量，金锁（Jinlock），银锁（Yinlock）
两个线程A,B
线程A执行时，先锁金锁，然后准备去锁银锁，两个线程出现了上下文切换，线程B执行了，线程B先锁银锁，因为银锁没有被A锁上，所以被B锁上了，然后线程B去锁金锁产生了死锁，下面用两个互斥量演示死锁。
代码演示：

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			//my_mutex.lock();
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			{


				my_mutex1.lock();		//先锁金锁 实际中两个lock间会执行其他的东西
				my_mutex2.lock();		//再锁银锁
				msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	
				my_mutex2.unlock();				//顺序无所谓
				my_mutex1.unlock();

			}
		}
	}


	bool outMsgLULproc(int &command)
	{
		//lock_guard<mutex>sbguard(my_mutex1);       //sbguard是对象名
		my_mutex2.lock();
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			my_mutex1.unlock();
			my_mutex2.unlock();
			return true;
		}	
		else
		{
			my_mutex1.unlock();
			my_mutex2.unlock();
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex1;           //创建一个互斥量
	mutex my_mutex2;     

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();

	//四 互斥量的概念
	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。有lock忘记unlock的问题非常难排查
	//为了防止忘记unlock（），引入了一个叫std::lock_guard的类模板
	//智能指针(unique_ptr<>)

	//std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock
	//要将保护量放在lock和unlock里


	//五 死锁
	/*
	**死锁问题的前提条件是：有至少两个锁，即至少两个互斥量，金锁（Jinlock），银锁（Yinlock）**
	两个线程A,B
	线程A执行时，先锁金锁，然后去锁银锁
	两个线程出现了上下文切换，线程B执行了，线程B先锁银锁，因为银锁没有被A锁上，所以被B锁上了，然后线程B去锁金锁
	此时产生了死锁
	线程A锁不了银锁，流程走不下去
	线程B锁不了金锁，流程走不下去
	*/

	//5.1死锁演示
}

在这里插入图片描述

3.2 死锁的解决方案

只要保证两个互斥量上锁的顺序一致，就不会造成死锁。
（解锁顺序不影响是否发生死锁）

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			//my_mutex.lock();
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			{


				my_mutex1.lock();		//先锁金锁 实际中两个lock间会执行其他的东西
				my_mutex2.lock();		//再锁银锁
				msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	
				my_mutex2.unlock();				//顺序无所谓
				my_mutex1.unlock();

			}
		}
	}


	bool outMsgLULproc(int &command)
	{
		//lock_guard<mutex>sbguard(my_mutex1);       //sbguard是对象名
		my_mutex1.lock();
		my_mutex2.lock();
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			my_mutex1.unlock();
			my_mutex2.unlock();
			return true;
		}	
		else
		{
			my_mutex1.unlock();
			my_mutex2.unlock();
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex1;           //创建一个互斥量
	mutex my_mutex2;     

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();

	//四 互斥量的概念
	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。有lock忘记unlock的问题非常难排查
	//为了防止忘记unlock（），引入了一个叫std::lock_guard的类模板
	//智能指针(unique_ptr<>)

	//std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock
	//要将保护量放在lock和unlock里


	//五 死锁
	/*
	**死锁问题的前提条件是：有至少两个锁，即至少两个互斥量，金锁（Jinlock），银锁（Yinlock）**
	两个线程A,B
	线程A执行时，先锁金锁，然后去锁银锁
	两个线程出现了上下文切换，线程B执行了，线程B先锁银锁，因为银锁没有被A锁上，所以被B锁上了，然后线程B去锁金锁
	此时产生了死锁
	线程A锁不了银锁，流程走不下去
	线程B锁不了金锁，流程走不下去
	死锁产生的关键是两个互斥量的上锁顺序不一致
	*/

	//5.1死锁演示
	//5.2死锁的一般解决方案
	//只要保证两个互斥量上锁的顺序一致，就不会造成死锁。

}

在这里插入图片描述
使用lock_guard产生死锁和解决死锁的方法相同。

3.3 std::lock()函数模板

能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，一个不行），不存在因为锁头的顺序问题导致出现死锁问题。如果互斥量中有一个没锁住，则等待，等待所有互斥量否锁住，才能继续往下走
特点：要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没成功，则立即解锁已经锁住的。
一般用来处理多个互斥量的情况
缺点：需要手动解锁
用一个std:lock（）和两个unlock来保护共享数据，示例：

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			//my_mutex.lock();
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			{


				//my_mutex1.lock();		//先锁金锁 实际中两个lock间会执行其他的东西
				//my_mutex2.lock();		//再锁银锁
				//使用std::lock()
				std::lock(my_mutex1, my_mutex2);    //相当与每个互斥量都调用了lock
				msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	

				my_mutex2.unlock();				//顺序无所谓
				my_mutex1.unlock();

			}
		}
	}


	bool outMsgLULproc(int &command)
	{
		//lock_guard<mutex>sbguard(my_mutex1);       //sbguard是对象名
		//my_mutex1.lock();
		//my_mutex2.lock();
		std::lock(my_mutex1, my_mutex2);
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			my_mutex1.unlock();
			my_mutex2.unlock();
			return true;
		}	
		else
		{
			my_mutex1.unlock();
			my_mutex2.unlock();
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex1;           //创建一个互斥量
	mutex my_mutex2;     

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();

	//四 互斥量的概念
	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。有lock忘记unlock的问题非常难排查
	//为了防止忘记unlock（），引入了一个叫std::lock_guard的类模板
	//智能指针(unique_ptr<>)

	//std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock
	//要将保护量放在lock和unlock里


	//五 死锁
	/*
	**死锁问题的前提条件是：有至少两个锁，即至少两个互斥量，金锁（Jinlock），银锁（Yinlock）**
	两个线程A,B
	线程A执行时，先锁金锁，然后去锁银锁
	两个线程出现了上下文切换，线程B执行了，线程B先锁银锁，因为银锁没有被A锁上，所以被B锁上了，然后线程B去锁金锁
	此时产生了死锁
	线程A锁不了银锁，流程走不下去
	线程B锁不了金锁，流程走不下去
	死锁产生的关键是两个互斥量的上锁顺序不一致
	*/

	//5.1死锁演示
	//5.2死锁的一般解决方案
	//只要保证两个互斥量上锁的顺序一致，就不会造成死锁。


	//5.3 std::lock()函数模板
	//能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，一个不行）
	//不存在因为锁头的顺序问题导致出现死锁问题。
	//如果互斥量中有一个没锁住，则等待，等待所有互斥量否锁住，才能继续往下走
	//特点：要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没成功，则立即解锁已经锁住的。
	//用来处理多个互斥量的情况


}

程序正常运行
在这里插入图片描述
但这样使用还存在这需要手动写解代码的问题。

3.4 std:lock_guard的std::adopt_lock参数

为了解决使用了std::lock()还需要手动解锁的问题，使用不需要手写解锁代码的std::lock_guard，但是在std::lock（mutex1,mutex2）中，已经上锁一次，再使用std::lock_guard还会再上锁一次，所以使用std::lock_guard中的adopt_lock参数，可以在不调用上锁函数，保证只锁一次。
示例代码如下：

// 并发与多线程2_4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <thread>
#include <list>
#include  <mutex>
using namespace std;


//vector<int>g_v = { 1,2,3 };
//
//void Myprint(int inum)
//{
//	cout << "myprint线程开始执行了，线程编号" << inum << endl;
//	cout << "myprint线程结束执行了，线程编号" << inum << endl;
//	cout << "id 为" << std::this_thread::get_id() << "打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
//
//}



class A
{
public:
	//把玩家命令放入到一个队列的进程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			//my_mutex.lock();
			cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
			{


				//my_mutex1.lock();		//先锁金锁 实际中两个lock间会执行其他的东西
				//my_mutex2.lock();		//再锁银锁
				//使用std::lock()
				std::lock(my_mutex1, my_mutex2);    //相当与每个互斥量都调用了lock
				std::lock_guard<mutex>sbguard1(my_mutex1, adopt_lock);
				std::lock_guard<mutex>sbguard2(my_mutex2, adopt_lock);
				msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列	

				//my_mutex2.unlock();				//顺序无所谓
				//my_mutex1.unlock();

			}
		}
	}


	bool outMsgLULproc(int &command)
	{
		//lock_guard<mutex>sbguard(my_mutex1);       //sbguard是对象名
		//my_mutex1.lock();
		//my_mutex2.lock();
		std::lock(my_mutex1, my_mutex2);
		if (!msgRecvQueue.empty())
		{
		    command = msgRecvQueue.front();      //返回第一个元素但不检查元素是否存在
			msgRecvQueue.pop_front();            //移除第一个元素但不返回
			//处理数据。。。。。
			my_mutex1.unlock();
			my_mutex2.unlock();
			return true;
		}	
		else
		{
			my_mutex1.unlock();
			my_mutex2.unlock();
			return false; 
		}
	
	}

	//读取命令的线程
	void outMsgRecvQueue()
	{
		int command = 0;	
		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULproc(command);
			if (result == true)
			{
			
				cout << "outMsgRecvQueue 执行，取出一个元素" << command << endl;
				//数据处理
			}

		
		}
		cout << "end" << endl;
	
	}
private:

	std::list<int>msgRecvQueue;
	mutex my_mutex1;           //创建一个互斥量
	mutex my_mutex2;     

};

int main()
{
 //   //一 创建线程和等待多个线程
	//vector<thread>mythreads;
	创建10个线程，线程入口函数统一使用 myprint
	1）多线程执行顺序是乱的
	2）这种join写法更容易写出稳定程序
	3）把thread对象放入到容器里，对管理大量线程有帮助
	//for (int i = 0; i < 10; i++)
	//{
	//	//创建10个线程，已经开始执行
	//	mythreads.push_back(thread(Myprint, i));
	//
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	//{
	//	iter->join();
	//}
	//cout << "I LOVE CHINA" << endl;

	//二 数据共享
	//2.1只读数据
	//2.2 有读有写
	//最简单的不崩溃处理 读和写不能同时进行
	//2.3其他案例
	//数据共享：    
	
	//三 共享数据的保护案例代码
	//网络游戏服务器，有两个自己创建的线程，一个线程手机玩家命令（数字表示），并把名利数据写入到一个队列中。
	//另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家的动作。
	//使用list，频繁的按顺序插入和删除时效率较高


	//用成员函数作为线程函数的方法写线程

	A myobja;
	thread myOutnMsg(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsg.join();
	myInMsgObj.join();

	//四 互斥量的概念
	//步骤：先lock 操作共享数据 然后unlock
	//lock和unlock要成对使用。有lock忘记unlock的问题非常难排查
	//为了防止忘记unlock（），引入了一个叫std::lock_guard的类模板
	//智能指针(unique_ptr<>)

	//std::lock_guard类模板 直接取代lock()和unlock(),用了类模板不能再用lock和unlock
	//要将保护量放在lock和unlock里


	//五 死锁
	/*
	**死锁问题的前提条件是：有至少两个锁，即至少两个互斥量，金锁（Jinlock），银锁（Yinlock）**
	两个线程A,B
	线程A执行时，先锁金锁，然后去锁银锁
	两个线程出现了上下文切换，线程B执行了，线程B先锁银锁，因为银锁没有被A锁上，所以被B锁上了，然后线程B去锁金锁
	此时产生了死锁
	线程A锁不了银锁，流程走不下去
	线程B锁不了金锁，流程走不下去
	死锁产生的关键是两个互斥量的上锁顺序不一致
	*/

	//5.1死锁演示
	//5.2死锁的一般解决方案
	//只要保证两个互斥量上锁的顺序一致，就不会造成死锁。


	//5.3 std::lock()函数模板
	//能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，一个不行）
	//不存在因为锁头的顺序问题导致出现死锁问题。
	//如果互斥量中有一个没锁住，则等待，等待所有互斥量否锁住，才能继续往下走
	//特点：要么两个互斥量都锁住，要么两个互斥量都没锁住。如果只锁了一个，另外一个没成功，则立即解锁已经锁住的。
	//用来处理多个互斥量的情况

	//5.4 std:lock_guard的std:adopt_lock参数



}

在这里插入图片描述
通过std::lock(mutex1,mutex2,…)和std::lock_guard相结合的方式，可以做到上锁时不考虑上锁顺序，同时不需要手写解锁代码。
总结：在需要保护共享数据时，最安全的方法时一个一个上锁，一个一个解锁。

Michael.Scofield
关注
专栏目录
C++并发与多线程（一）
dddgggd的博客
04-27 461
第一节 并发基本概念及实现， 进程 线程基本概念 一 并发线程 进程的基本概念和综述 1.1 并发： 两个或者更多的任务（独立的活动）同时发生：一个程序同时执行多个独立任务。 单核cpu，某一时刻只能执行一个任务，由操作系统调度，每秒钟进行多次所谓的“任务切换”。 假象（不是真正的并发））这种切换（上下文切换）是要有时间开销的。 1.2 可执行程序 例如windows下的exe文件 1.3 进程 一个可执行程序运行以后即创建了一个进程。 运行起来的可执行文件叫做一个进程。 1.4 线程 每个进程都有一个主线
c++11 多线程基础
D_Guco的专栏
06-04 844
在c++11中，c++标准库中就增加了关于多线程的一些操作，在此之前我们不得不调用系统底层的多线程函数，或者用第三方的线程库，多少还是有些不便，现在我们可以用标准库中的多线程函数来开发多线程程序了。下面就介绍一下基本的用法。 #include #include void thread_test(int a,int b) { std::cout << "thread_test:a +
C++11并发与多线程【第四节】
afgqwjgfjqwgfg的博客
04-20 250
第四节 创建多个线程、数据共享问题分析、案例代码一、创建和等待多个线程1.1 多个线程的执行顺序1.2 主线程等待所有的子线程运行结束，最后主线程结束，使用的是join，使用join更容易写出稳定的程序1.3 把thread对象放入容器进行管理，便于对一次性创建的大量线程进行管理二、数据共享问题2.1 只读的数据2.2 有读有写三.如何保证安全访问共享数据3.1 共享数据的保护案例 一、创建和等待多个线程 1.1 多个线程的执行顺序 #include<iostream> #include<
c++，使用容器统一管理各个对象的thread线程指针
ganfanren00001的博客
12-11 1397
## c++，使用容器统一管理各个对象的thread线程指针 **问题： 解决工程中对象创建的线程难以管理的困难。** 一、 **thread对象通过调用运算符()创建线程的方法,一般的创建线程的语法是: 1、线程对象，显式调用调用运算符()：** ```cpp thread oThread = thread(function,parameters); ``` **2、线程指针，通过new调用调用运算符()：** ```cpp thread *oThread = new thread(functi
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 8万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C++ 并发多线程日志处理
02-28
在C++编程中，多线程日志处理是一项重要的任务，尤其在高并发环境中，能够有效地记录、管理和分析系统运行时的信息。C++11引入了标准库中的`<thread>`，使得多线程编程变得更加方便，同时也为日志处理带来了新的挑战...
C++并发与多线程-运行时选择线程数量
01-20
在C++编程中，多线程和并发是提高程序性能的重要技术。特别是在处理大量数据或进行复杂计算时，通过合理地使用多线程可以让多个任务并行执行，从而充分利用CPU资源。本文主要讨论如何在运行时选择合适的线程数量，以...
C++11的多线程并发编程（一）
01-20
C++11的多线程并发编程（一） 在疫情期间以及未来毕业后即将工作的憧憬中，给自己立个学习flag，学习并第一次通过CSDN记录下C++11的多线程并发编程。初学者的我写的不好，还望大家多多指正与批评， 学习多线程并发...
yolov5目标检测多线程C++部署
最新发布
08-12
** yolov5目标检测多线程C++部署详解** 在计算机视觉领域，目标检测是一项关键技术，用于识别图像或视频帧中的特定对象。YOLO（You Only Look Once）是一种高效的目标检测算法，以其实时性能和相对较高的准确性而...
C++多线程编程（入门实例）
weixin_33834137的博客
09-27 383
      　　多线程在编程中有相当重要的地位，我们在实际开发时或者找工作面试时总能遇到多线程的问题，对多线程的理解程度从一个侧面反映了程序员的编程水平。 　　其实C++语言本身并没有提供多线程机制（当然目前C++ 11新特性中，已经可以使用std::thread来创建线程了，因为还没有系统地了解过，所以这里不提了。），但Windows系统为我们提供了相关API，我们可以使用他们来进行多线...
多线程执行顺序
abcd1f2的专栏
07-05 2053
一直对多线程编程这一块很陌生，决定花一点时间整理一下。 os:ubuntu 10.04  c++ 1.最基础，进程同时创建5个线程，各自调用同一个函数 [html] view plaincopyprint? #include iostream>  #include pthread.h> //多线程相关操作头文件，可移植众多平台    using namespace 
[C++11 std::thread] 使用C++11 编写 Linux 多线程程序
JoeBlackZQQ的专栏
12-26 1万+
From: http://www.ibm.com/developerworks/cn/linux/1412_zhupx_thread/index.html   本文讲述了如何使用 C++11 编写 Linux 下的多线程程序，如何使用锁，以及相关的注意事项，还简述了 C++11 引入的一些高级概念如 promise/future 等。 0 评论： 朱
C++11 并发编程教程 - Part 1 : thread 初探
u012432785的博客
08-03 307
C++11 引入了一个新的线程库，包含了用于启动、管理线程的诸多工具，与此同时，该库还提供了包括互斥量、锁、原子量等在内的同步机制。在这个系列的教程中，我将尝试向大家展示这个新库提供的大部分特性。 为了能够编译本文的示例代码，你需要有一个支持 C++11 的编译器，笔者使用的是 GCC4.6.1（你需要添加 "-std=c++11" 或 "-std=c++0x" 编译选项以启动 GCC 对
C++ queue使用原理介绍以及在多线程的应用
dingzj2000的专栏
01-04 1万+
1 queue原理 1.1 queue简述 std::queue: 模板类queue定义在<queue>头文件中。队列(Queue)是一个容器适配器(Container adaptor)类型，被特别设计用来运行于FIFO(First-in first-out)场景，在该场景中，只能从容器一端添加(Insert)元素，而在另一端提取(Extract)元素。只能从容器”...
＜C++多线程1＞线程启动、结束、创建线程的方法、join、detach
ZYunfei的博客
04-21 761
thread和join thread是一个类，使用的时候需要包含头文件 #include<thread>。 一个进程产生的同时会产生一个主进程，也就是main函数，我们可以定义子进程，这样在一个进程中就有多条“线路”可走，但是会存在一个问题，主线程走完了子线程还没有走完，此时操作系统将强制停止子线程，程序出错，因此需要 join用来阻塞主线程。下面给出一个demo： #include<iostream> #include<thread> using namespace s
C++实现多线程及其三种方法实现多线程同步
小伟锅的博客
06-18 3万+
1.调用windows API实现多线程 #include "stdafx.h" #include #include #include DWORD WINAPI myfun1(LPVOID lpParameter); //声明线程函数 DWORD WINAPI myfun2(LPVOID lpParameter); using namespace std; int _tmain(in
C/C++之读写JSON数据
dddgggd的博客
02-05 9724
前言 在进行配置文件读取或者进行RPC(Remote Produce Call)，我们需要在两个进程间传递大量的数据，这时我们一般会选择json/xml/protobuf来序列化数据，加快数据的传输与解析速度。 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON采用完全独立于语言的文本格式，这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。关于json数据格式的具体介绍，大家可以自己去搜索，今天主要介绍下C/C++如何
深入理解C++并发与多线程
"C++并发与多线程" 在C++编程中，并发和多线程是提高程序效率和响应性的重要工具。C++11引入了内置的多线程支持，使得开发人员能够更容易地利用现代多核处理器的潜力。本书深入探讨了C++中的并发编程，覆盖了从基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael.Scofield

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值