目录
C++11中的unique_lock使用起来要比lock_guard更灵活,但是效率会第一点,内存的占用也会大一点。同样,unique_lock也是一个类模板,但是比起lock_guard,它有自己的成员函数来更加灵活进行锁的操作。
使用方式和lock_guard一样,不同的是unique_lock有不一样的参数和成员函数。它的定义是这样的:
std::unique_lock<std::mutex> munique(mlock);
这样定义的话和lock_guard没有什么区别,最终也是通过析构函数来unlock。
std::adopt_lock
unique_lock也可以加std::adopt_lock参数,表示互斥量已经被lock,不需要再重复lock。该互斥量之前必须已经lock,提前加锁,才可以使用该参数。
std::try_to_lock
可以避免一些不必要的等待,会判断当前mutex能否被lock,如果不能被lock,可以先去执行其他代码。这个和adopt不同,不需要自己提前加锁。举个例子来说就是如果有一个线程被lock,而且执行时间很长,那么另一个线程一般会被阻塞在那里,反而会造成时间的浪费。那么使用了try_to_lock后,如果被锁住了,它不会在那里阻塞等待,它可以先去执行其他没有被锁的代码。具体实现过程如下:
#include <iostream>
#include <mutex>
std::mutex mlock;
void workPor1(int& s)
{
for (int i = 1; i <= 5000; i++)
{
std::unique_lock<std::mutex> munique(mlock, std::try_to_lock);
if (munique.owns_lock() == true)
{
s += i;
}
else
{
// 执行一些没有共享内存的代码
}
}
}
void workPro2(int& s)
{
for (int i = 5001; i <= 10000; i++)
{
std::unique_lock<std::mutex> munique(mlock, std::try_to_lock);
if (munique.owns_lock() == true)
{
s += i;
}
else
{
// 执行一些没有共享内存的代码
}
}
}
int main()
{
int ans = 0;
std::thread t1(workPro1, std::ref(ans));
std::thread t2(workPro2, std::ref(ans));
t1.join();
t2.join();
std::cout << ans << std::endl;
return 0;
}
std::defer_lock
这个参数表示暂时先不lock,之后手动去lock,但是使用之前也是不允许去lock。一般用来搭配unique_lock的成员函数去使用。下面就列举defer_lock和一些unique_lock成员函数的使用方法。
当使用了defer_lock参数时,在创建了unique_lock的对象时就不会自动加锁,那么就需要借助lock这个成员函数来进行手动加锁,当然也有unlock来手动解锁。这个和mutex的lock和unlock使用方法一样,实现代码如下:
#include <iostream>
#include <mutex>
std::mutex mlock;
void workPro1(int& s)
{
for (int i = 1; i <= 5000; i++)
{
std::unique_lock<std::mutex> munique(mlock, std::defer_lock);
munique.lock();
s += i;
munique.unlock(); // 这里可以不用unlock,可以通过unique_lock的析构函数unlock
}
}
void workPro2(int& s)
{
for (int i = 5001; i <= 10000; i++)
{
std::unique_lock<std::mutex> munique(mlock, std::defer_lock);
munique.lock();
s += i;
munique.unlock();
}
}
int main()
{
int ans = 0;
std::thread t1(workPro1, std::ref(ans));
std::thread t2(workPro2, std::ref(ans));
t1.join();
t2.join();
std::cout << ans << std::endl;
return 0;
}
还有一个成员函数是try_lock,和上面的try_to_lock参数的作用差不多,判断当前是否能lock,如果不能,先去执行其他的代码并返回false,如果可以,进行加锁并返回true,代码如下:
void workPro1(int& s)
{
for (int i = 1; i <= 5000; i++)
{
std::unique_lock<std::mutex> munique(mlock, std::defer_lock);
if (munique.try_lock() == true)
{
s += i;
}
else
{
// 处理一些没有共享内存的代码
}
}
}
release函数,解除unique_lock和mutex对象的联系,并将原mutex对象的指针返回出来。如果之前的mutex已经加锁,需在后面自己手动unlock解锁,代码如下:
void workPro2(int& s)
{
for (int i = 1; i <= 5000; i++)
{
std::unique_lock<std::mutex> munique(mlock); // 这里是自动lock
std::mutex *m = munique.release();
s += i;
m->unlock();
}
}
unique_lock的所有权的传递
对越unique_lock的对象来说,一个对象只能和一个mutex锁唯一对应,不能存在一对多或者多对一的情况,不然会造成死锁的出现。所以如果想要传递两个unique_lock对象对mutex的权限,需要运用到移动语义或者移动构造函数两种方法。
移动语义:
std::unique_lock<std::mutex> munique1(mlock);
std::unique_lock<std::mutex> munique2(std::move(munique1));
// 此时munique1失去mlock的权限,并指向空值,munique2获取mlock的权限
移动构造函数:
std::unique_lock<std::mutex> rtn_unique_lock()
{
std::unique_lock<std::mutex> tmp(mlock);
return tmp;
}
void work1(int& s) {
for (int i = 1; i <= 5000; i++) {
std::unique_lock<std::mutex> munique2 = rtn_unique_lock();
s += i;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.unique_lock取代lock_guard
unique_lock是个类模板,工作中,一般lock_guard(推荐使用);lock_guard取代了mutex的lock()和unlock();
unique_lock比lock_guard灵活很多,效率上差一点,内存占用多一点。
2. unique_lock的第二个参数
lock_guard可以带第二个参数:
std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);// std::adopt_lock标记作用;
2.1 std::adopt_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;
}
2.3 std::defer_lock
用std::defer_lock的前提是,你不能自己先lock,否则会报异常
std::defer_lock的意思就是并没有给mutex加锁:初始化了一个没有加锁的mutex。
我们借着defer_lock的话题,来介绍一些unique_lock的重要成员函数
3. unique_lock的成员函数
3.1 lock(),加锁
3.2 unlock(),解锁
defer_lock、lock()与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();//画蛇添足,但也可以
}
}
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()
返回它所管理的mutex对象指针,并释放所有权;也就是说,这个unique_lock和mutex不再有关系。严格区分unlock()与release()的区别,不要混淆。
如果原来mutex对像处于加锁状态,你有责任接管过来并负责解锁。(release返回的是原始mutex的指针)。实例代码如下:
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
std::unique_lock<std::mutex> sbguard(my_mutex);
std::mutex *ptx = sbguard.release(); //现在你有责任自己解锁了
msgRecvQueue.push_back(i);
ptx->unlock(); //自己负责mutex的unlock了
}
}
-
为什么有时候需要unlock();因为你lock()锁住的代码段越少,执行越快,整个程序运行效率越高。有人也把锁头锁住的代码多少成为锁的粒度,粒度一般用粗细来描述;
a)锁住的代码少,这个粒度叫细,执行效率高;
b)锁住的代码多,这个粒度叫粗,执行效率低;
要学会尽量选择合适粒度的代码进行保护,粒度太细,可能漏掉共享数据的保护,粒度太粗,影响效率。
选择合适的粒度是高级程序员能力和实力的体现;
4. unique_lock所有权的传递
std::unique_lock<std::mutex> sbguard(my_mutex);//所有权概念
sbguard拥有my_mutex的所有权;sbguard可以把自己对mutex(my_mutex)的所有权转移给其他的unique_lock对象;
所以unique_lock对象这个mutex的所有权是可以转移,但是不能复制。
std::unique_lock<std::mutex> sbguard1(my_mutex);
std::unique_lock<std::mutex> sbguard2(sbguard1);//此句是非法的,复制所有权是非法的
-
std::unique_lock<std::mutex> sbguard2(std::move(sbguard));//移动语义,现在先当与sbguard2与my_mutex绑定到一起了 //现在sbguard1指向空,sbguard2指向了my_mutex
方法1 :std::move()
方法2:return std:: unique_lock<std::mutex> 代码如下:
-
std::unique_lock<std::mutex> rtn_unique_lock() { std::unique_lock<std::mutex> tmpguard(my_mutex); return tmpguard;//从函数中返回一个局部的unique_lock对象是可以的。三章十四节讲解过移动构造函数。 //返回这种举报对象tmpguard会导致系统生成临时unique_lock对象,并调用unique_lock的移动构造函数 } void inMsgRecvQueue() { for (int i = 0; i < 10000; i++) { std::unique_lock<std::mutex> sbguard1 = rtn_unique_lock(); msgRecvQueue.push_back(i); } }