unique_lock详解

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

#include "pch.h"
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A_Mutex {
public:

	void inMsgRecvQueue()  //把收到的消息（玩家命令）到一个队列的线程。100000次便于观察
	{
		for (int i = 0; i < 100000; i++)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素" << i << endl;

			{   //加上大括号可以让lock_guard提前（在处理其他代码前）解锁（超出作用域时（大括号）析构）
				//lock_guard <mutex> guard(my_mutex);
				//unique_lock <mutex> u_lock(my_mutex);  //unique_lock

				/*
				//try_to_lock
				unique_lock <mutex> u_lock_try(my_mutex,try_to_lock);
				if (u_lock_try.owns_lock())
				{
					//拿到了锁
					msgRecvQueue.push_back(i);
					//....处理其他代码
				}
				else
				{
					//没拿到锁
					cout << "inMsgRecvQueue()执行,但没拿到锁,只能干别的事" << i << endl;
				}
				*/

				unique_lock <mutex> u_lock_defer(my_mutex, defer_lock);   //没有加锁的my_mutex


				/* 
				//lock与unlock的使用
				u_lock_defer.lock();    //调用u_lock_defer的成员函数lock()，自带解锁，自己手工解锁也不会有问题（但画蛇添足）
				
				
				u_lock_defer.unlock(); //因为有一些非共享代码要处理，手工暂时解锁，体现灵活性

				//处理一些非共享代码

				u_lock_defer.lock(); //处理完后，再重新加锁

				//再次加锁后，再处理共享代码
				*/

				//成员函数try_lock
				if (u_lock_defer.try_lock() == true)
				{

					//拿到了锁
					msgRecvQueue.push_back(i);
					//....处理其他代码
				}
				else
				{
					//没拿到锁
					cout << "inMsgRecvQueue()执行,但没拿到锁,只能干别的事" << i << endl;
				}

				msgRecvQueue.push_back(i);

				//...处理代码
				//msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接送到消息队列里去
				
			}
			//....处理其他代码
		}
		return;
	}

	bool outMsgLULProc(int &command)
	{
		//lock_guard <mutex> guard(my_mutex);   //guard为对象名,使用lock_guard时，lock与unlock不能再使用
		unique_lock <mutex> u_lock(my_mutex);  
		//std::chrono::milliseconds dura(20000); //20000毫秒==20秒
		//std::this_thread::sleep_for(dura);  //sleep 20s
		if (!msgRecvQueue.empty()) //消息不为空
		{
			command = msgRecvQueue.front();//返回第一个元素
			msgRecvQueue.pop_front();//弹出第一个元素（移除）
			
			return true;
		}
		return false;

	}
	void outMsgRecvQueue()//把数据从消息队列中取出的线程
	{
		int command = 0;
		for (int i = 0; i < 100000; i++)
		{
			if (outMsgLULProc(command) == true)
			{
				cout << "outMsgRecvQueue()执行" << i << endl;
				//可以对command进行数据处理
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列为空" << i << endl;
			}
		}
		cout << "end" << endl;
		return;
	}
private:
	list <int> msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送过来的命令
	mutex my_mutex; //创建了一个互斥量（一个锁）

};

int main()
{
	A_Mutex myobj_mutex;
	thread myOutnMsgObj(&A_Mutex::outMsgRecvQueue, &myobj_mutex);  //第二参数是引用（就无需拷贝），才能保证线程里用的是同一对象
	thread myInMsgobj(&A_Mutex::inMsgRecvQueue, &myobj_mutex);
	myOutnMsgObj.join();
	myInMsgobj.join();

	//一:unique_lock取代lock_guard :  unique_lock <mutex> u_lock(my_mutex); 取代  lock_guard <mutex> guard(my_mutex);
	//unique_lock是个类模板。工作中，一般lock_guard()足够了，推荐使用。
	//unique_lock比lock_guard灵活很多；效率上差一点，内存占用多一点

	//二:unique_lock的第二个参数
	
	//（2.1）std::adopt_lock
	//用adopt_lock的前提是互斥量已被lock，通知lock_guard的构造函数无需再lock
	//lock_guard的第二个参数：lock_guard <mutex> guard(my_mutex,std::adopt_lock);   //adopt_lock 起标记作用
	//unique_lock也可以带std::adopt_lock参数，含义相同
	
	//（2.2）std::try_to_lock
	//会尝试用mutex的lock去锁定这个mutex，但如果没有锁定成功，也会立即返回，并不会一直阻塞
	//用try_to_lock的前提是不能自己手动去lock

	//（2.3）std::defer_lock
	//用defer_lock的前提是不能自己手动去lock（同try_to_lock）
	//使用它并不会给mutex加锁，作用是初始化了一个没有加锁的mutex

	//三：unique_lock的成员函数
	//（3.1）lock()，加锁
	//（3.2）unlock()，解锁，虽然成员函数lock（）自带解锁，但unlock可以更加灵活（比如有一些非共享代码要处理：可以暂时解锁再加锁）
	//（3.3）try_lock(),尝试给互斥量加锁，如果拿不到锁，则返回false（不阻塞），如果拿到了锁，返回true。
	//（3.4）release(),返回它所管理的mutex对象指针，并释放所有权；也就是说，这个unique_lock和mutex不再有关系
	//如果原来mutex对象处于加锁状态，需接管过来并负责解锁

	//lock锁住的代码段越少，执行越快，整个程序运行效率越高
	//锁住的代码的多少称为锁的 粒度。粒度一般用粗细来描述
	//选择合适的粒度，是高级程序员的能力和实力的体现

	//四：unique_lock所有权的传递 
	//unique_lock <mutex> u_lock_defer(my_mutex);    所有权概念： u_lock_defer拥有my_mutex的所有权
	//u_lock_defer可以把自己对my_mutex的所有权 转移 给其他的unique_lock对象，但是不能 复制
	//转移：unique_lock <mutex> u_lock_defer2(std::move(u_lock_defer));    //移动语义，相当于u_lock_defer2与my_mutex绑定在一起了。u_lock_defer则指向空，u_lock_defer2指向空 


	cout << "主线程执行完毕" << endl; //执行完这句，主线程退出
	return 0; 
}