0
点赞
收藏
分享

微信扫一扫

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

大明宫 2022-11-01 阅读 71
消息队列#include加锁虚拟化云计算

上一节说到了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上。
  1. my_mutex.lock(); //要先lock，后续才能使用unique_lock的adopt_lock参数
  2. 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() 上锁。
  • 方便随时锁上，随时开锁。
  1. std::unique_lock<std::mutex> uniq_mux(my_mutex, std::defer_lock); 没有加锁的my_mutex
  2. uniq_mux.lock(); //后面可以自己unlock
  3. //处理共享代码
  4. uniq_mux.unlock();
  5. //处理一些非共享代码
  6. uniq_mux.lock();
  7. //处理共享代码

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的所有权是属于可以转移，但是不能复制。 
  1. std::unique_lock<std::mutex> mutex_guard1(my_mutex);

  3. std::unique_lock<std::mutex> mutex_guard2(mutex_guard1); //复制所有权是非法的

  5. std::unique_lock<std::mutex> mutex_guard2(std::move(mutex_guard1));
  6. //移动语义，现在相当于mutex_guard2和my_mutex绑定到一起了,现在mutex_guard1指向空, mutex_guard2指向了my_mutex
  • 另外一种转移所有权的方式：
  1. std::unique_lock<std::mutex> rtn_unique_lock(){
  2. std::unique_lock<std::mutex> tmp_guard(my_mutex);
  3. return tmp_guard;
  4. //从函数返回一个局部的unique_lock对象时可以的。
  5. //返回这种局部对象tmpguard会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数
  6. }
  • 调用

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


举报

相关推荐

UNIX(多线程)：09---线程unique_lock（上）

加锁互斥锁并行操作云平台云计算

unique_lock

C++多线程

unique_lock()使用

c++开发语言

unique_lock详解

c++开发语言后端

UNIX(多线程)：15---死锁(Dead Lock)

#include互斥锁死锁Spark大数据

unique_lock＜mutex＞的使用

visual studioc++ide

多线程-Lock锁

java后端lock

[多线程]lock锁

java开发语言

[C++] 互斥锁(unique_lock、lock_guard)

c++开发语言后端互斥锁互斥Python后端开发

C++ 多线程 读锁之后不能跟写锁 shared_lock之后不能跟unique_lock 死锁 解决方案

c++开发语言#includeios读锁
0 条评论