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

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

unique_lock详解

1.unique_lock取代lock_guard

// 并发与多线程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);
				std::unique_lock<std::mutex>sbguard1(my_mutex1);
				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);
		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		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参数


	//六 unique_lock取代lock_guard	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。


}

在这里插入图片描述

2.unique_lock的第二个参数

2.1 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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				my_mutex1.lock();                     //in线程后到
				std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前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);

		std::chrono::milliseconds dura(20000);    //等待20s
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来


		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	//使用
}

2.2 try_to_lock

尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞,用try_to_ 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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				if (sbguard1.owns_lock())
				{
					cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
					msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
				}
				else
				{
					cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(10);    //等待10ms
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来
		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数
	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try to lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try to lock的前提是不可以手动上锁，否则异常


}

当没有上锁成功时，try to lock可以通过判断条件进入自定义事件
在这里插入图片描述

2.3 std::defer_lock

初始化一个没有上锁的互斥量mutex

3.unique_lock的成员函数

3.1 lock() 加锁

通过调用unique_lock的成员函数lock，自动上锁和解锁，配合defer_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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;

					//创建没有加锁的my_mutex1
					std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					sbguard1.lock();              //不需要手动解锁

					msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(100);    //等待20s
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try to lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try to lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数
	// 8.1 lock()

}

在这里插入图片描述

3.2 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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;

					//创建没有加锁的my_mutex1
					std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					sbguard1.lock();              //不需要手动解锁

					//处理共享代码

					sbguard1.unlock();              //不需要手动解锁
					//处理非共享代码

					sbguard1.lock();              //不需要手动解锁
					//处理共享代码

					msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(100);    //等待20s
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try to lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try to lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数

	// 8.1 lock()

	//8.2 unlock()  希望处理些非共享代码，处理非共享代码，然后再lock上
	//即unique_lock通过成员函数可以实现手动上锁，自动解锁和手动解锁

}

程序稳定运行
在这里插入图片描述

3.3 try_lock

与defer_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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					

					//创建没有加锁的my_mutex1
					std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					//sbguard1.lock();              //不需要手动解锁

					//处理共享代码

					//sbguard1.unlock();              //不需要手动解锁
					//处理非共享代码

					//sbguard1.lock();              //不需要手动解锁
					//处理共享代码

					if (sbguard1.try_lock() == true)
					{
						cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
						msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列
						
					}
					else
					{
						cout << "inMsgRecvQueue执行，上锁失败" << endl;
						
					}

					

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(200);    //等待200ms
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try_to_lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try_to_lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数

	// 8.1 lock()

	//8.2 unlock()  希望处理些非共享代码，处理非共享代码，然后再lock上
	//即unique_lock通过成员函数可以实现手动上锁，自动解锁和手动解锁
	//也可以自己在程序结尾自己家unlock  unique_lock会作出判断

	//8.3 try_lock 尝试给互斥量加锁，如果拿不到锁，则返回false，拿到了则返回true，程序不阻塞

}

在这里插入图片描述

3.4 release()

// 并发与多线程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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					

					//创建没有加锁的my_mutex1
					//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					//sbguard1.lock();              //不需要手动解锁

					//处理共享代码

					//sbguard1.unlock();              //不需要手动解锁
					//处理非共享代码

					//sbguard1.lock();              //不需要手动解锁
					//处理共享代码
					
					std::unique_lock<std::mutex>sbguard1(my_mutex1);		// 创建一个加锁的mutex
					std::mutex *ptx = sbguard1.release();					//将sbguard1与my_mutex1解绑  手动解锁
					//if (sbguard1.try_lock() == true)
					//{
						cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
						msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

						ptx->unlock();						//手动解锁
				
					//}
					//else
					//{
					//	cout << "inMsgRecvQueue执行，上锁失败" << endl;
					//	
					//}

					

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(10);    //等待10ms
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try_to_lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try_to_lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数

	// 8.1 lock()

	//8.2 unlock()  希望处理些非共享代码，处理非共享代码，然后再lock上
	//即unique_lock通过成员函数可以实现手动上锁，自动解锁和手动解锁
	//也可以自己在程序结尾自己家unlock  unique_lock会作出判断

	//8.3 try_lock 尝试给互斥量加锁，如果拿不到锁，则返回false，拿到了则返回true，程序不阻塞


	//8.4 release(),返回它管理的mutex对象指针，并释放所有权，也就是说，这个unique_lock和mutex不再有关系
	//严格区分unlock()和release()的区别，不要混淆
	//如果原来mutex对象处于加锁状态，如果release了，则需要手动解锁
	//release返回原始的mutex指针
	//为什么有时候需要unlock():因为lock锁住的代码段越少，执行越快，整个程序运行效率越高
	//乘互斥量锁住的代码多少，称为粒度 ，粒度一般用粗细描述
	//要选择合适粒度的代码来保护共享数据，粒度太细影响效率，粒度太粗影响效率
	
}

在这里插入图片描述

4.unique_lock所有权的传递

一个mutex只和一个mutex绑定在一起
所有权概念： sbguard1拥有my_mutex1的所有权，sbguard1可以把对my_mutex1的所有权转一个其他unique_lock对象，
所以，unique_lock的所有权，可以转移，不能复制。
std::unique_lockstd::mutexsbguard1(my_mutex1);
std::unique_lockstd::mutexsbguard2(sbguard1); 这样是非法的
std::unique_lockstd::mutexsbguard2(std::move(sbguard1)); //将sbguard1的所有权转移给sbguard2

4.1 调用std::move转移所有权

// 并发与多线程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();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					

					//创建没有加锁的my_mutex1
					//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					//sbguard1.lock();              //不需要手动解锁

					//处理共享代码

					//sbguard1.unlock();              //不需要手动解锁
					//处理非共享代码

					//sbguard1.lock();              //不需要手动解锁
					//处理共享代码
					
					std::unique_lock<std::mutex>sbguard1(my_mutex1);		// 创建一个加锁的mutex
					std::unique_lock<std::mutex>sbguard2(std::move(sbguard1)); //将sbguard1的所有权转移给sbguard2
					//现在sbguard1指向空 sbguard2指向了my_mutex1
					/*std::mutex *ptx = sbguard1.release();	*/				//将sbguard1与my_mutex1解绑  手动解锁
					//if (sbguard1.try_lock() == true)
					//{
						cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
						msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

						sbguard2.unlock();						//手动解锁
				
					//}
					//else
					//{
					//	cout << "inMsgRecvQueue执行，上锁失败" << endl;
					//	
					//}

					

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(10);    //等待10ms
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try_to_lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try_to_lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数

	// 8.1 lock()

	//8.2 unlock()  希望处理些非共享代码，处理非共享代码，然后再lock上
	//即unique_lock通过成员函数可以实现手动上锁，自动解锁和手动解锁
	//也可以自己在程序结尾自己家unlock  unique_lock会作出判断

	//8.3 try_lock 尝试给互斥量加锁，如果拿不到锁，则返回false，拿到了则返回true，程序不阻塞


	//8.4 release(),返回它管理的mutex对象指针，并释放所有权，也就是说，这个unique_lock和mutex不再有关系
	//严格区分unlock()和release()的区别，不要混淆
	//如果原来mutex对象处于加锁状态，如果release了，则需要手动解锁
	//release返回原始的mutex指针
	//为什么有时候需要unlock():因为lock锁住的代码段越少，执行越快，整个程序运行效率越高
	//乘互斥量锁住的代码多少，称为粒度 ，粒度一般用粗细描述
	//要选择合适粒度的代码来保护共享数据，粒度太细影响效率，粒度太粗影响效率
	


	// 九 unique_lock的所有权传递
	// 一个mutex只和一个mutex绑定在一起  
	//所有权概念： sbguard1拥有my_mutex1的所有权，sbguard1可以把对my_mutex1的所有权转一个其他unique_lock对象，
	//所以，unique_lock的所有权，可以转移，不能复制。
	//std::unique_lock<std::mutex>sbguard1(my_mutex1);
	//std::unique_lock<std::mutex>sbguard2(sbguard1);  这样是非法的
	//std::unique_lock<std::mutex>sbguard2(std::move(sbguard1)); //将sbguard1的所有权转移给sbguard2
}

在这里插入图片描述
在这里插入图片描述

4.2 使用A的类成员函数返回unique_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:
	//把玩家命令放入到一个队列的进程
	std::unique_lock<std::mutex>rtn_unique_lock()
	{
		std::unique_lock<std::mutex>temguard(my_mutex1);
		return temguard;
		//从函数返回一个局部的unique_lock对象是可以的，移动构造函数
		//返回这种局部对象temguard会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数
	
	}
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			//my_mutex.lock();
			
			{


				//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);
				//std::unique_lock<std::mutex>sbguard1(my_mutex1);

				//my_mutex1.lock();                     //in线程后到
				//std::unique_lock<std::mutex>sbguard1(my_mutex1,adopt_lock);  //使用了adopt_lock 需要提前lock

				//尝试加锁
				//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::try_to_lock);         //使用此参数的条件时互斥量没有上锁

				//if (sbguard1.owns_lock())              //如果尝试上锁成功
				//{
					

					//创建没有加锁的my_mutex1
					//std::unique_lock<std::mutex>sbguard1(my_mutex1, std::defer_lock);

					//sbguard1.lock();              //不需要手动解锁

					//处理共享代码

					//sbguard1.unlock();              //不需要手动解锁
					//处理非共享代码

					//sbguard1.lock();              //不需要手动解锁
					//处理共享代码
					
					//std::unique_lock<std::mutex>sbguard1(my_mutex1);		// 创建一个加锁的mutex
					//std::unique_lock<std::mutex>sbguard2(std::move(sbguard1)); //将sbguard1的所有权转移给sbguard2
					//现在sbguard1指向空 sbguard2指向了my_mutex1
					/*std::mutex *ptx = sbguard1.release();	*/				//将sbguard1与my_mutex1解绑  手动解锁
					//if (sbguard1.try_lock() == true)
					//{

					std::unique_lock<std::mutex>sbguard1 = rtn_unique_lock();
						cout << "inMsgRecvQueue执行，插入一个元素" << i << endl;
						msgRecvQueue.push_back(i);     //假设数字i为命令 放入队列

						sbguard1.unlock();						//手动解锁
				
					//}
					//else
					//{
					//	cout << "inMsgRecvQueue执行，上锁失败" << endl;
					//	
					//}

					

				//}
				//else								  // 如果上锁失败
				//{
				//	cout << "inMsgRecvQueue 执行，但没有上锁。。。。" << endl;
				//}

					

				//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);

	

		std::unique_lock<std::mutex>sbguard1(my_mutex1);
		std::chrono::milliseconds dura(10);    //等待10ms
		std::this_thread::sleep_for(dura);		  //休息一定时长  outMsgLULproc先跑起来

		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参数


	//六 unique_lock取代lock_guard
	//unique_lock是个类模板，工作中推荐使用lock_guard
	//lock_guard取代了mutex的lock和unlock
	//unique_lock比lock_guard灵活，效率略差，内存占用稍多。

	//七 unique_lock的第二个参数

	// 7.1 adopt_lock
	//lock_guard中的adopt_lock起标记作用 表示互斥量已经被lock了，在写这个标记前需要把互斥量lock 否则报错
	//adopt的效果是：假设调用方 线程已经拥有了互斥的所有权（已经lock成功了）
	//unique_lock也有adopt_lock标记，含义相同。
	//灵活性：
	//对于同一个锁 如果其中一个线程上了锁，则另一个也需要这个锁的线程就会处于等待状态，知道前一个线程解锁，会浪费很多时间
	

	//7.2 std::try_to_lock
	//尝试用mutex的lock（）去锁定lock，但如果没有锁定成功，也会立即返回，并不会阻塞
	//用try_to_lock的前提是不可以手动上锁，否则异常
	

	//7.3 std::defer_lock
	//使用defer_lock的前提是 不能自己先lock，否则异常，与try to lock一样，与adopt_lock不同
	//defer_lock  初始化一个没有加锁的mutex
	//借着defer_lock的话题，介绍一些unique_lock的重要成员函数


	//八 unique_lcok的成员函数

	// 8.1 lock()

	//8.2 unlock()  希望处理些非共享代码，处理非共享代码，然后再lock上
	//即unique_lock通过成员函数可以实现手动上锁，自动解锁和手动解锁
	//也可以自己在程序结尾自己家unlock  unique_lock会作出判断

	//8.3 try_lock 尝试给互斥量加锁，如果拿不到锁，则返回false，拿到了则返回true，程序不阻塞


	//8.4 release(),返回它管理的mutex对象指针，并释放所有权，也就是说，这个unique_lock和mutex不再有关系
	//严格区分unlock()和release()的区别，不要混淆
	//如果原来mutex对象处于加锁状态，如果release了，则需要手动解锁
	//release返回原始的mutex指针
	//为什么有时候需要unlock():因为lock锁住的代码段越少，执行越快，整个程序运行效率越高
	//乘互斥量锁住的代码多少，称为粒度 ，粒度一般用粗细描述
	//要选择合适粒度的代码来保护共享数据，粒度太细影响效率，粒度太粗影响效率
	


	// 九 unique_lock的所有权传递
	// 一个mutex只和一个mutex绑定在一起  
	//所有权概念： sbguard1拥有my_mutex1的所有权，sbguard1可以把对my_mutex1的所有权转一个其他unique_lock对象，
	//所以，unique_lock的所有权，可以转移，不能复制。
	//std::unique_lock<std::mutex>sbguard1(my_mutex1);
	//std::unique_lock<std::mutex>sbguard2(sbguard1);  这样是非法的
	//std::unique_lock<std::mutex>sbguard2(std::move(sbguard1)); //将sbguard1的所有权转移给sbguard2
}

在这里插入图片描述
在这里插入图片描述
可以看到my_mutex1的地址被绑定到了sbguard1上了

Michael.Scofield
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++笔记之vector和thread结合使用
小勇博客
06-22 901
code review!
C++ 并发多线程日志处理
02-28
多线程日志处理 C++实现 参考用例
c++多线程入门(2)
TOPEE362的博客
07-31 784
传递参数与移交归属权
C++11并发与多线程【第四节】
afgqwjgfjqwgfg的博客
04-20 231
第四节 创建多个线程、数据共享问题分析、案例代码一、创建和等待多个线程1.1 多个线程的执行顺序1.2 主线程等待所有的子线程运行结束，最后主线程结束，使用的是join，使用join更容易写出稳定的程序1.3 把thread对象放入容器进行管理，便于对一次性创建的大量线程进行管理二、数据共享问题2.1 只读的数据2.2 有读有写三.如何保证安全访问共享数据3.1 共享数据的保护案例 一、创建和等待多个线程 1.1 多个线程的执行顺序 #include<iostream> #include<
创建和等待多个线程
weixin_45983489的博客
03-10 662
一、创建和等待多个线程 多个线程执行顺序是乱的，跟内部操作系统的运行调度机制有关； 推荐使用join()方法使主线程等待所有子线程执行结束后，主线程再结束，这样的程序更稳定。 将每次创建的thread对象放入vector容器中，这样可以一次创建大量线程进行管理 vector<thread>mythread; for (int i = 0; i < 10; i++) { mythread.push_back(thread(myprint, i));//创建并开始执行线程 }
c++11最简单的线程池实现
木牛的博客
04-27 353
线程池是在处理高并发任务中有比较重要的价值,他的实现最基本原理就生产者和消费者模型,刚开始就开一定数量的线程,以程序中的某些功能模块为对象,以生产者与消费者模型为基本原理,不断使用这些固定数量的线程调度进行处理,避免了在高并发情况下,不断开辟线程造成的进程资源消耗.下面是一个简单的线程池程序,主要使用C++11中一些简单的新特性的最简单的线程池实现.ThreadPool.h #pragma once #include <iostream> #include<stdlib.h>
C++并发与多线程
08-30
非常不错，值得收藏
C++11 并发指南之多线程初探
12-20
Linux 程序员都用过 Pthread, 但有了 C++11 的 std::thread 以后，你可以在语言层面编写多线程程序了，直接的好处就是多线程程序的可移植性得到了很大的提高，所以作为一名 C++ 程序员，熟悉 C++11 的多线程编程方式...
C++并发与多线程-运行时选择线程数量
01-20
使用std::thread::hardware_concurrency() 来获得当前系统可以真正并发的线程数量，和cpu的核心数有关。 #include #include #include #include #include #include std::mutex g_lock; template struct accumulate_...
C++11的多线程并发编程（一）
01-20
C++11的多线程并发编程（一） 在疫情期间以及未来毕业后即将工作的憧憬中，给自己立个学习flag，学习并第一次通过CSDN记录下C++11的多线程并发编程。初学者的我写的不好，还望大家多多指正与批评， 学习多线程并发...
C++中vector多线程操作
weixin_37684907的博客
11-12 803
C++中vector多线程操作
C++11 thread库 用法举例
CN_BIT的博客
03-11 334
join()和detach() #include "pch.h" #include <iostream> #include <thread> #include <string> #include <chrono> #include <sstream> #include <ctime> #include <iomanip> using namespace std; void print_time() { auto n
《C++ Concurrency in Action》笔记4 vector<thread>
t114211200的博客
09-15 1138
将多个thread对象放到vector中，之后顺序执行join。看如下示例： vector v_id(20); void f(int i) { v_id[i] = i; } void call_by_main() { vector v; for (int i = 0; i < 20; ++i) { v.push_back(thread(f,i)); } for_each(v.be
C++多线程详解
gjg244的博客
02-16 329
多线程开发学习
C++ | 多线程使用vector
RandyOliver's House
06-21 554
而如果加上第4句，先扩容到1个很大的范围，但是clear仅仅是将成员清除，使得size为0，因此多线程 emplace_back的时候，就能够直接emplace_back了，不会发生扩容问题。多线程需要同时对同一个vector进行写入的时候，先扩容到一个值，避免各个线程单独扩容，保证程序稳定有效进行。第一反应是，既然是Clean函数，肯定就是想清空这个数组，清空之前还要reserve一下，不是多此一举吗？代码单线程测试了一下，也是没问题的，多线程的问题出在哪里呢？问题在于程序使用的是多线程。
C++关于vector和多线程的数据的传递和合并
scottar的博客
03-15 3788
1、 前言 关于vector 的传递的参数的方式 注意，三种方式分别有对应的const形式，不在此讨论。 三种方式对应的调用形式分别为： function1(vec)，传入值 function2(vec)，传入引用 function3(&vec),传入地址 三种方式的效果分别为： 会发生拷贝构造 不会发生拷贝构造 不会发生拷贝构造 2、实验目标 希望能够将vecto...
C++多线程（五）：创建多个线程以及数据共享问题
milkhoko的博客
07-04 2247
创建和等待多个线程 vetor vector（称为容器） 是同一种类型的对象的集合,每个对象都有一个对应的整数索引值。 先看下面例程： // C++stu_03.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //本例程用于学习创建多线程以及数据共享问题 #include <iostream> #include <windows.h> #include <thread> #include<vector> using namespa
多线程操作C++ STL vector出现概率coredump问题
最新发布
nihao_2014的博客
12-17 146
重点关注frame 1， 其中有：_M_start， _M_finish， _M_end_of_storage， 熟悉vector底层动态分配的朋友， 应该能猜出这三个变量的含义， _M_start指向vector头， _M_finish指向vector尾， _M_end_of_storage指向预分配内存的尾。还有一个问题： 上面的结论是_M_finish越过了_M_end_of_storage， 导致coredump, 那如果让_M_end_of_storage不被越过呢？这种场景是非常普遍的。
c++11 多线程使用
weixin_58004346的博客
03-31 261
线程函数的传参都是拷贝,例如参数是引用类型,也是会拷贝传值的,原因是与底层实现有关(创建线程时参数首先传递给构造函数再传递给线程函数这个过程里出问题了) – 解决方案 “ref(引用对象)” 意思是强制以左值引用去传递。Lock guard类通过RAII的方式对互斥锁进行了封装，在构造函数中进行加锁，在析构函数中自动解锁。考察条件变量的使用,跟wait()与POSIX库用法差不多,都是需要循环检测条件是否满足。智能锁像智能指针一样RALL机制,管理的资源声明周期随对象释放资源。//方法一:不确定是否正确。
c++ tcp并发多线程客户端
12-13
c tcp并发多线程客户端是一种采用C语言编写的客户端程序，利用了多线程技术在同一时间内与多个服务器建立并发连接。通过使用多线程，该客户端可以同时处理多个服务器的请求，提高了程序的效率和并发性能。 在实现过程中，首先需要使用socket函数创建套接字，然后通过调用connect函数与服务器建立连接。之后，可以创建多个线程，每个线程都可以负责与一个服务器进行通信。在每个线程内部，可以使用send和recv函数来发送和接收数据。 为了保证多线程间数据的同步和互斥访问，可以采用互斥锁技术，比如使用pthread_mutex_init函数初始化互斥锁，并在关键代码段使用pthread_mutex_lock和pthread_mutex_unlock函数进行加锁和解锁操作。 此外，还需要使用pthread_create函数来创建多个线程，并通过传递参数指定不同的服务器地址和端口号等信息。每个线程内部都可以使用独立的套接字进行通信操作。 通过使用多线程实现并发，可以在同一时间内与多个服务器进行通信，大大提高了客户端的效率和并发处理能力。但同时也需要注意处理线程间的同步和互斥问题，以避免数据竞争和不一致的情况发生。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Michael.Scofield

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

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

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

打赏作者

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

抵扣说明：

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

余额充值