并发与多线程六：unique_lock详解
#include <iostream> #include <vector> #include <map> #include <string> #include <thread> #include<list> #include<mutex> using namespace std; class A { public: void inmsgrectqueue() { for (int i = 0; i<100; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { //std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 my_mutex1.lock();//2 要先lock(),后续才能用unique_lock()的std::adopt_lock()参数 std::unique_lock<std::mutex> sbguard1(my_mutex1, std::adopt_lock);//2 msgrectqueue.push_back(i);//假设这个数字i就是收到的命令，直接弄到消息队列中去。 } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; } //把数据从消息队列中取出的线程 void outmsgrectqueue() { int command = 0; for (int i = 0; i<100; ++i) { bool result = outmsglulproc(command); if(result==true) { cout << "outmsgrectqueue（）执行，取出一个元素" << command << endl; } else { //消息队列为空 cout << "outmsgrectqueue()执行，但目前消息队列中为空" << i << endl; } cout << "end" << endl; } } private: std::list<int> msgrectqueue;// 容器，专门用于代表玩家给咱们发送过来的命令 std::mutex my_mutex1;//创建一个互斥量 }; int main() { A myobja; std::thread myoutmsgobj(&A::outmsgrectqueue, &myobja);//第二个参数是(引用，才能保证线程里用的是同一个对象 std::thread myinmsgobj(&A::inmsgrectqueue, &myobja); myoutmsgobj.join(); myinmsgobj.join(); //一.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);//adopt_lock起标记作用 //2.1 std::adopt_lock:表示这个互斥量已经被lock了(必须把互斥量提前lock了，否则会报异常） //std::adopt_lock标记的效果就是“假设调用方线程已经拥有了互斥的所有权（已经lock成功了） //同之lock_guard不需要在构造函数中lock这个互斥量了 //unique_lock也可以带std::adopt标记，含义相同，就是不希望在unique_lock的构造函数中lock这个mutex； return 0; }
try_to_lock
void inmsgrectqueue() { for (int i = 0; i<1000; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { std::unique_lock<std::mutex> sbguard1(my_mutex1, std::try_to_lock);//3 if (sbguard1.owns_lock()) { //拿到了锁 msgrectqueue.push_back(i); //.... //其它处理代码 } else { //没拿到锁 cout << "inmsgrectqueue()执行,没拿到锁，只能干点别的事" << i << endl; } } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 std::chrono::milliseconds dura(2000); //1秒 == 1000毫秒 std::this_thread::sleep_for(dura);//休息一定时间，这里如果休息一定时间那么inmsgrectqueue里就会等待相同的时间 if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; }
//2.2 std::try_to_lock //我们会常尝试用mutex的lock()线去锁定这个mutex，但如果没有锁定成功，就会立即返回，并不会阻塞在那里 //用这个try_to_lock的前提是自己不能先去lock();
lock和unlock
void inmsgrectqueue() { for (int i = 0; i<1000; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { std::unique_lock<std::mutex> sbguard1(my_mutex1, std::defer_lock); sbguard1.lock();不用自己unlock //处理共享代码 //为什么又存在unlock，因为可能有一些非共享代码要处理的时候，可以先unlock sbguard1.unlock(); //处理一些非共享代码，处理完后再lock sbguard1.lock(); msgrectqueue.push_back(i); } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1); if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; }
//2.3 std::defer_lock //不能先lock，否则会报异常 //defer_lock的意思是并没有给mutex加锁；初始化了一个没有加锁的mutex //三:unique_lock的成员函数 //(3.1) lock(),加锁 //(3.2) unlock(),解锁
try_lock
void inmsgrectqueue() { for (int i = 0; i<1000; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { std::unique_lock<std::mutex> sbguard1(my_mutex1, std::defer_lock);//3 if (sbguard1.try_lock() == true) { msgrectqueue.push_back(i); } else { //没拿到锁 cout << "inmsgrectqueue()执行,没拿到锁，只能干点别的事" << i << endl; } } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 std::chrono::milliseconds dura(2000); //1秒 == 1000毫秒 std::this_thread::sleep_for(dura);//休息一定时间，这里如果休息一定时间那么inmsgrectqueue里就会等待相同的时间 if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; }
//(3.3) try_lock(),解锁
release
void inmsgrectqueue() { for (int i = 0; i<1000; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { std::unique_lock<std::mutex> sbguard1(my_mutex1);//4 std::mutex *ptx = sbguard1.release();//有责任自己解锁这个my_mutex1 msgrectqueue.push_back(i); ptx->unlock();//自己负责mutex的unlock了 } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; }
//(3.4） release(),返回它所管理的mutex对象指针，并释放所有权；也就是说unique_lock和mutex不在有联系
//严格区分unlock()和release的区别，不要混淆
//如果原来mutex对象处于加锁状态，则需要解锁
//为什么有时候需要unlock，因为lock锁住的代码越少，执行越快，整个程序运行效率越高
//有人也把锁头锁住的代码的多少称为锁的 粒度，粒度一般用粗细来描述；
//锁住的代码越少，粒度越细，执行效率越高
unique_lock所有权的传递 mutex
std::unique_lock<std::mutex> rtn_unique_lock() { std::unique_lock<std::mutex> tmpguard(my_mutex1); return tmpguard;//从函数返回一个局部的unique_lock对象是可以的 //返回这种局部对象tmpguard会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数 } void inmsgrectqueue() { for (int i = 0; i<1000; ++i) { cout << "inmsgrectqueue()执行，插入一个元素" << i << endl; { //std::unique_lock<std::mutex> sbguard2(std::move(sbguard1));//1 移动语义，现在相当于sbguard2和my_mutex1绑定 //现在sbguard1指向空，sbguard2指向my_mutex1; std::unique_lock<std::mutex> sbguard1 = rtn_unique_lock();//2 msgrectqueue.push_back(i); } } } bool outmsglulproc(int &command) { std::unique_lock<std::mutex> sbguard1(my_mutex1);//1 if(!msgrectqueue.empty()) { //消息不为空 int command = msgrectqueue.front();//返回第一个元素，但不检查元素是否存在 msgrectqueue.pop_back();//移除第一个元素，但不返回； //这里就考虑处理数据... return true; } return false; } //四：unique_lock所有权的传递 mutex //std::unique_lock<std::mutex> sbguard1(my_mutex1); 所有权概念 //sbguard1拥有my_mutex1的所有权 //sbguard1可以把自己对mutex(my_mutex1)的所有权转移给其他的unique_lock对象； //所以，unique_lock对象这个mutex的所有权属于 可以转移 但不能复制。
浙公网安备 33010602011771号