6.unique_lock详解

目录

一、unique_lock取代lock_guard

unique_lock是个类模板，工作中，一般使用lock_guard(推荐使用！)

lock_guard取代了mutex的lock()和unlock();

unique_lock比lock_guard灵活很多，效率上差一点，内存占用多一点。

二、unique_lock的第二个参数

lock_guard可以带第二个参数：

std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);// std::adopt_lock标记作用；

2.1 std::addopt_lock

表示这个互斥量已经被lock了（你必须要把互斥量提前lock了 ，否者会报异常）；

std::adopt_lock标记的效果就是假设调用一方已经拥有了互斥量的所有权（已经lock成功了）；通知lock_guard不需要再构造函数中lock这个互斥量了。

unique_lock也可以带std::adopt_lock标记，含义相同，就是不希望再unique_lock()的构造函数中lock这个mutex。

用std::adopt_lock的前提是，自己需要先把mutex lock上；用法与lock_guard相同。

2.2 std::try_to_lock

我们会尝试用mutex的lock()去锁定这个mutex,但如果没有锁定成功，我也会立即返回，并不会阻塞在那里；

用这个try_to_lock的前提是你自己不能先lock。实例代码如下：

#include<iostream>
#include<thread>
#include<string>
#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::unique_lock<std::mutex> sbguard(my_mutex, std::try_to_lock);
				if (sbguard.owns_lock())
				{
					//拿到了锁
					msgRecvQueue.push_back(i); 
					//...
					//其他处理代码
				}
				else
				{
					//没拿到锁
					cout << "inMsgRecvQueue()执行，但没拿到锁头，只能干点别的事" << i << endl;
				}
			}
		}
	}
 
	bool outMsgLULProc(int &command)
	{
		my_mutex.lock();//要先lock(),后续才能用unique_lock的std::adopt_lock参数
		std::unique_lock<std::mutex> sbguard(my_mutex, std::adopt_lock);
 
		std::chrono::milliseconds dura(20000);
		std::this_thread::sleep_for(dura);  //休息20s
 
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素。但不返回；
			
			return true;
		}
		return false;
	}
	//把数据从消息队列取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);
 
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//处理数据
			}
			else
			{
				//消息队列为空
				cout << "inMsgRecvQueue()执行，但目前消息队列中为空！" << i << endl;
			}
		}
		cout << "end!" << endl;
	}
 
private:
	std::list<int> msgRecvQueue;//容器（消息队列），代表玩家发送过来的命令。
	std::mutex my_mutex;//创建一个互斥量（一把锁）
};
 
int main()
{
	A myobja;
 
	std::thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
 
	myOutMsgObj.join();
	myInMsgObj.join();
 
	cout << "主线程执行！" << endl;
 
	return 0;
}

总结：

• 尝试用mutx的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
• 使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
• 前提：不能提前lock();
• owns_locks()方法判断是否拿到锁，如拿到返回true

2.3 std::defer_lock：

• 如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
• 不给它加锁的目的是以后可以调用unique_lock的一些方法
• 前提：不能提前lock

三、unique_lock的成员函数（前三个与std::defer_lock的联合使用）

3.1 lock()：加锁

unique_lock<mutex> myUniLock(myMutex， defer_lock);
myUniLock.lock();

不用自己unlock();

3.2 unlock()：解锁

void inMsgRecvQueue(){
    for (int i = 0; i < 10000; i++){
        
        cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
        std::unique_lock<std::mutex> sbguard(my_mutex, std::defer_lock);//没有加锁的my_mutex
        sbguard.lock();//咱们不用自己unlock
        //处理共享代码

        //因为有一些非共享代码要处理
        sbguard.unlock();
        //处理非共享代码要处理。。。

        sbguard.lock();
        //处理共享代码

        msgRecvQueue.push_back(i);
        //...
        //其他处理代码
        sbguard.unlock();//画蛇添足，但也可以
    }
}

因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再lock()。

3.3 try_lock()：尝试给互斥量加锁

如果拿不到锁，返回false，否则返回true。

void inMsgRecvQueue(){
    for (int i = 0; i < 10000; i++)
    {
        std::unique_lock<std::mutex> sbguard(my_mutex, std::defer_lock);//没有加锁的my_mutex

        if (sbguard.try_lock() == true)//返回true表示拿到锁了
        {
            msgRecvQueue.push_back(i);
            //...
            //其他处理代码
        }
        else
        {
            //没拿到锁
            cout << "inMsgRecvQueue()执行，但没拿到锁头，只能干点别的事" << i << endl;
        }
    }
}

3.4 release()：

• unique_lock
  myUniLock(myMutex);相当于把myMutex和myUniLock绑定在了一起，release()就是解除绑定，返回它所管理的mutex对象的指针，并释放所有权
• mutex* ptx =
  myUniLock.release();所有权由ptx接管，如果原来mutex对象处理加锁状态，就需要ptx在以后进行解锁了。

lock的代码段越少，执行越快，整个程序的运行效率越高。
a.锁住的代码少，叫做粒度细，执行效率高；
b.锁住的代码多，叫做粒度粗，执行效率低；

四、unique_lock所有权的传递

unique_lock myUniLock(myMutex);把myMutex和myUniLock绑定在了一起，也就是myUniLock拥有myMutex的所有权

1. 使用move转移

myUniLock拥有myMutex的所有权，myUniLock可以把自己对myMutex的所有权转移，但是不能复制。
unique_lock myUniLock2(std::move(myUniLock));
现在myUniLock2拥有myMutex的所有权。

2. 在函数中return一个临时变量，即可以实现转移

unique_lock<mutex> aFunction()
{
    unique_lock<mutex> myUniLock(myMutex);
    //移动构造函数那里讲从函数返回一个局部的unique_lock对象是可以的
    //返回这种局部对象会导致系统生成临时的unique_lock对象，并调用unique_lock的移动构造函数
    return myUniLock;
}

在函数中return一个临时变量，即可以实现转移*

unique_lock<mutex> aFunction()
{
    unique_lock<mutex> myUniLock(myMutex);
    //移动构造函数那里讲从函数返回一个局部的unique_lock对象是可以的
    //返回这种局部对象会导致系统生成临时的unique_lock对象，并调用unique_lock的移动构造函数
    return myUniLock;
}