文章12 | 阅读 6491 | 点赞0
unique_lock是个类模板，工作中，一般lock_guard(推荐使用)；lock_guard取代了mutex的lock()和unlock();
unique_lock比lock_guard灵活很多，效率上差一点，内存占用多一点。
lock_guard可以带第二个参数：
std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);// 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相同。
我们会尝试用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;
}用std::defer_lock的前提是，你不能自己先lock,否则会报异常
std::defer_lock的意思就是并没有给mutex加锁：初始化了一个没有加锁的mutex。
我们借着defer_lock的话题，来介绍一些unique_lock的重要成员函数
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();//画蛇添足，但也可以
}
}尝试给互斥量加锁，如果拿不到锁，返回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;
}
}
}返回它所管理的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)锁住的代码多，这个粒度叫粗，执行效率低；
要学会尽量选择合适粒度的代码进行保护，粒度太细，可能漏掉共享数据的保护，粒度太粗，影响效率。
选择合适的粒度是高级程序员能力和实力的体现；
std::unique_lockstd::mutex sbguard(my_mutex);//所有权概念
sbguard拥有my_mutex的所有权；sbguard可以把自己对mutex(my_mutex)的所有权转移给其他的unique_lock对象；
所以unique_lock对象这个mutex的所有权是可以转移，但是不能复制。
std::unique_lockstd::mutex sbguard1(my_mutex);
std::unique_lockstd::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_lockstd::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);
}
}注：该文是C++11并发多线程视频教程笔记，详情学习：https://study.163.com/course/courseMain.htm?courseId=1006067356
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/u012507022/article/details/85909567
内容来源于网络，如有侵权，请联系作者删除！