UNIX(多线程)：10---线程unique_lock(下)

用户3479834

发布于 2021-02-03 14:58:20

5860

上一节说到了lock_guard在一些场景下使用起来并没有unique_lock灵活，我们将取代lock_guard：

unique_lock是个类模板，工作中，一般lock_guard(推荐使用)，lock_guard取代了mutex的lock()和unlock()。
unique_lock比lock_guard灵活很多，效率上差一点，内存占用多一点。

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>




using namespace std;


class A
{
public:
//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
//std::lock_guard<mutex> in_mutex_guard(my_mutex);
std::unique_lock<mutex> in_mutex_guard(my_mutex);
msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中
//其他代码
}
}


//在这个函数中加锁
bool outMsgMutPro(int& command)
{


//std::lock_guard<mutex> out_mutex_guard1(my_mutex);
std::unique_lock<mutex> out_mutex_guard1(my_mutex);


if (!msgRecvQueue.empty())
{
//消息队列不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front();           //移除第一个元素，但不返回
return true;
}
return false;
}


//把消息从消息队列中取出的线程
void outMsgRecvQueue()
{
int command{};


for (int i = 1; i < 10000; ++i)
{
bool ret = outMsgMutPro(command);
if (ret)
{
cout << "outMsgMutPro执行了，取出一个元素" << command << endl;
//这里就针对具体的命令具体处理
//...
}
else {
//消息队列为空
cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl;
}
}
cout << "outMsgRecvQueue()执行完毕" << endl;
}


private:
std::list<int> msgRecvQueue;  //容器（消息队列），专门代表玩家给我们发来的命令
std::mutex my_mutex;
};


int main()
{
A obja;
std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象
std::thread inMsgThread(&A::inMsgRecvQueue, &obja);


inMsgThread.join();
outMsgThread.join();


//主线程执行
std::cout << "主线程结束" << std::endl;
return 0;
}

缺省情况下，unique_lock和lock_guard作用相同。

unique_lock的第二个参数

std::adopt_lock

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

表示这个互斥量已经被lock了（你必须要把互斥量提前lock了，否则会报异常）
- 标记的效果就是 “假设调用方线程已经拥有了互斥的所有权（表示已经lock()成功了）。
- 通知lock_guard不需要再构造函数中lock这个互斥量了。
unique_lock也可以带std::adopt_lock标记，含义相同，就是不希望再unique_lock()的构造函数中lock这个mutex。
用这个adopt_lock的前提是，你需要自己先把mutex先lock上。

my_mutex.lock(); //要先lock，后续才能使用unique_lock的adopt_lock参数std::unique_lock<mutex> in_mutex_guard(my_mutex, std::adopt_lock);

std::try_to_lock

【引例】
其中一个线程执行拿到锁后，阻塞20秒，另一个线程由于拿不到锁，也跟着阻塞20秒。

class A
{
public:
//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
//std::lock_guard<mutex> in_mutex_guard(my_mutex);
my_mutex.lock(); //要先lock，后续才能使用unique_lock的adopt_lock参数
std::unique_lock<mutex> in_mutex_guard(my_mutex, std::adopt_lock);
msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中
//其他代码
}
}


//在这个函数中加锁
bool outMsgMutPro(int& command)
{


//std::lock_guard<mutex> out_mutex_guard1(my_mutex);
std::unique_lock<mutex> out_mutex_guard1(my_mutex);
std::chrono::milliseconds dura(2000); // 1秒 = 1000毫秒
std::this_thread::sleep_for(dura);    //休息一定的时长


if (!msgRecvQueue.empty())
{
//消息队列不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front();           //移除第一个元素，但不返回
return true;
}
return false;
}


//把消息从消息队列中取出的线程
void outMsgRecvQueue()
{
int command{};


for (int i = 1; i < 10000; ++i)
{
bool ret = outMsgMutPro(command);
if (ret)
{
cout << "outMsgMutPro执行了，取出一个元素" << command << endl;
//这里就针对具体的命令具体处理
//...
}
else {
//消息队列为空
cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl;
}
}
cout << "outMsgRecvQueue()执行完毕" << endl;
}


private:
std::list<int> msgRecvQueue;  //容器（消息队列），专门代表玩家给我们发来的命令
std::mutex my_mutex;
};


int main()
{
A obja;
std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象
std::thread inMsgThread(&A::inMsgRecvQueue, &obja);


inMsgThread.join();
outMsgThread.join();


//主线程执行
std::cout << "主线程结束" << std::endl;
return 0;
}

引出try_to_lock：
- 使用try_to_lock时，我们会尝试用mutex的lock去锁定这个mutex，但如果没有锁定成功，我们也会立即返回，并不会阻塞在那里。
- 用这个try_to_lock的前提是你自己不能先去lock。同一个mutex调用两次lock()，程序会卡死。
使用try_to_lock参数示例

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
//使用try_to_lock参数
std::unique_lock<mutex> in_mutex_guard(my_mutex, std::try_to_lock);
if (in_mutex_guard.owns_lock())
{
//拿到了锁
msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中
//其他代码
}
else
{
//没拿到锁
cout << "inMsgRecvQueue()执行了，但没拿到锁，只能干其他的事" << i << endl;
}
}
}
//在这个函数中加锁
bool outMsgMutPro(int& command)
{
//std::lock_guard<mutex> out_mutex_guard1(my_mutex);
std::unique_lock<mutex> out_mutex_guard1(my_mutex);
std::chrono::milliseconds dura(2000); // 1秒 = 1000毫秒
std::this_thread::sleep_for(dura);    //休息一定的时长

if (!msgRecvQueue.empty())
{
//消息队列不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front();           //移除第一个元素，但不返回
return true;
}
return false;
}
//把消息从消息队列中取出的线程
void outMsgRecvQueue()
{
int command{};
for (int i = 1; i < 10000; ++i)
{
bool ret = outMsgMutPro(command);
if (ret)
{
cout << "outMsgMutPro执行了，取出一个元素" << command << endl;
//这里就针对具体的命令具体处理
//...
}
else {
//消息队列为空
cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl;
}
}
cout << "outMsgRecvQueue()执行完毕" << endl;
}


private:
std::list<int> msgRecvQueue;  //容器（消息队列），专门代表玩家给我们发来的命令
std::mutex my_mutex;
};


int main()
{
A obja;
std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象
std::thread inMsgThread(&A::inMsgRecvQueue, &obja);
inMsgThread.join();
outMsgThread.join();
//主线程执行
std::cout << "主线程结束" << std::endl;
return 0;
}

std::defer_lock

用这个defer_lock的前提是你不能自己先lock，否则会报异常。
defer_lock的意思就是并没有给mutex加锁：初始化了一个没有加锁的mutex。
通过defer_lock的话题，介绍一些unique_lock 的重要成员函数

unique_lock的成员函数

lock() 加锁

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
//使用defer_lock参数
std::unique_lock<mutex> in_mutex_guard(my_mutex, std::defer_lock); //没加锁的my_mutex
in_mutex_guard.lock(); //后面会自己unlock
msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中
}
}
//在这个函数中加锁
bool outMsgMutPro(int& command)
{
//std::lock_guard<mutex> out_mutex_guard1(my_mutex);
std::unique_lock<mutex> out_mutex_guard1(my_mutex);
if (!msgRecvQueue.empty())
{
//消息队列不为空
command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在
msgRecvQueue.pop_front();           //移除第一个元素，但不返回
return true;
}
return false;
}
//把消息从消息队列中取出的线程
void outMsgRecvQueue()
{
int command{};
for (int i = 1; i < 10000; ++i)
{
bool ret = outMsgMutPro(command);
if (ret)
{
cout << "outMsgMutPro执行了，取出一个元素" << command << endl;
//这里就针对具体的命令具体处理
//...
}
else {
//消息队列为空
cout << "outMsgRecvQueue执行了，但是当前消息队列为空" << i << endl;
}
}
cout << "outMsgRecvQueue()执行完毕" << endl;
}
private:
std::list<int> msgRecvQueue;  //容器（消息队列），专门代表玩家给我们发来的命令
std::mutex my_mutex;
};


int main()
{
A obja;
std::thread outMsgThread(&A::outMsgRecvQueue, &obja); //第二个参数是引用，保证线程里操作同一个对象
std::thread inMsgThread(&A::inMsgRecvQueue, &obja);
inMsgThread.join();
outMsgThread.join();
//主线程执行
std::cout << "主线程结束" << std::endl;
return 0;
}

unlock() 解锁

有时有一些分共享代码需要处理，所以需要把锁解开去处理非共享代码。
处理完后又想处理共享代码，再次调用lock() 上锁。
方便随时锁上，随时开锁。

std::unique_lock<std::mutex> uniq_mux(my_mutex, std::defer_lock); 没有加锁的my_mutexuniq_mux.lock(); //后面可以自己unlock			//处理共享代码			uniq_mux.unlock();//处理一些非共享代码uniq_mux.lock();//处理共享代码

try_lock()

尝试给互斥量加锁，如果拿不到锁，则返回false，如果拿到了锁，返回true，这个函数不阻塞的。

//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
//使用defer_lock参数
std::unique_lock<mutex> in_mutex_guard(my_mutex, std::defer_lock); //没加锁的my_mutex
//使用try_lock()函数
if (in_mutex_guard.try_lock() == true)
{
//拿到锁了
msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中
}
else
{
//没拿到锁
cout << "inMsgRecvQueue() 执行，但没有拿到锁，只能干点别的事" << i << endl;
}
}
}

release()

返回它所管理的mutex对象指针，并释放所有权，也就是说，这个unique_lock和mutext不再有关系。
严格区分unlock（）和release（）的区别，不要混淆。
- 如果原来mutex对象处于加锁状态，你有责任接管过来并负责解锁。（release返回的是原始mutex指针）

//把收到的消息（玩家命令）加入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 1; i < 10000; ++i)
{
cout << "inMsgRecvQueue执行了，插入一个元素" << i << endl;
std::unique_lock<mutex> in_mutex_guard(my_mutex);
std::mutex* ptr_mutex = in_mutex_guard.release();


msgRecvQueue.push_back(i);    //假设这个数字就是玩家发来的命令，加入到消息队列中


//获取mutex指针后，需要自行unlock()
ptr_mutex->unlock();
}
}

unique_lock()函数使用小结

为什么有时候需要unlock()：
- 因为你lock锁住的代码段越少，执行越快，整个程序运行效率越高。
有人也把锁头锁住的代码多少称为锁的粒度，粒度一般用粗细来描述：
- a）锁住的代码少，这个粒度叫细，执行效率高。
- b）锁住的代码多，粒度叫粗，那执行效率就低。
要学会尽量选择合适粒度的代码进行保护，粒度太细，可能漏掉共享数据的保护，粒度太粗，影响效率。
选择合适的粒度，是高级程序员的能力和实力的体现。

unique_lock所有权的传递

std::unique_lock<std::mutex> mutex_guard(my_mutex);  //所有权概念

mutex_guard拥有my_mutex的所有权。
mutex_guard可以把自己对mutex (比如my_mutex) 的所有权转移给其他的unique_lock对象。
所以，unique_lock对象这个mutex的所有权是属于可以转移，但是不能复制。

std::unique_lock<std::mutex> mutex_guard1(my_mutex);
std::unique_lock<std::mutex> mutex_guard2(mutex_guard1); //复制所有权是非法的
std::unique_lock<std::mutex> mutex_guard2(std::move(mutex_guard1));//移动语义，现在相当于mutex_guard2和my_mutex绑定到一起了,现在mutex_guard1指向空, mutex_guard2指向了my_mutex

另外一种转移所有权的方式：

std::unique_lock<std::mutex> rtn_unique_lock(){	std::unique_lock<std::mutex> tmp_guard(my_mutex);	return tmp_guard;	//从函数返回一个局部的unique_lock对象时可以的。	//返回这种局部对象tmpguard会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数}

调用

std::unique_lock<mutex> mutex_guard = rtn_unique_lock();

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-01-04，如有侵权请联系 cloudcommunity@tencent.com 删除

c++

编程算法

本文分享自游戏开发司机微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

c++

编程算法

登录后参与评论

0 条评论

热度

UNIX(多线程)：10---线程unique_lock(下)

UNIX(多线程)：10---线程unique_lock(下)

上一节说到了lock_guard在一些场景下使用起来并没有unique_lock灵活，我们将取代lock_guard：

unique_lock的第二个参数

std::adopt_lock

std::try_to_lock

std::defer_lock

unique_lock的成员函数

lock() 加锁

unlock() 解锁

try_lock()

release()

unique_lock()函数使用小结

unique_lock所有权的传递

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐