c++学习|17.6 unique_lock详解 c++学习|c++

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

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock sbguard1(my_mutex_1); msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接弄到消息队列中 } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); if (!msgRecvQueue.empty()) { //消息不为空 command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在； msgRecvQueue.pop_front(); //移除第一个元素，但不返回 return true; } return false; } //把数据从消息队列中取出的线程 void outMsgRecvQueue() { int command = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

二、unique_lock的第二个参数
lock_guard 可以带第二个参数；
<1>std::adopt_lock
表示这个互斥量已经被 lock 了(你必须要把互斥量提前 lock 了，否则会报异常)
std::adopt_lock 标记的效果就是"假设调用方线程已经拥有了互斥的所有权" (已经lock()成功了)；
通知 lock_guard 不需要在构造函数中 lock() 这个互斥量了；
unique_lock 也可以代 std::adopt_lock 标记，含义相同，就是不希望在unique_lock的构造函数函数中lock()这个mutex。
用这个adopt_lock的前提是，你需要自己先把mutex先lock()上。
<2>std::try_to_lock
我们会尝试用 mutex 的 lock 去锁定这个 mutex，但如果没有锁成功，我们也会返回，不会阻塞在那里。
用这个try_to_lock的前提是你自己不能先去lock。

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock guard_1(my_mutex_1, std::try_to_lock); if (guard_1.owns_lock()) { //拿到了锁 msgRecvQueue.push_back(i); // 假设这个数字i就是我收到的命令，直接弄到消息队列中 //...... //其他处理代码 } else { //没拿到锁 cout << "inMsgRecvQueue()执行，但没有拿到锁，只能干点别的事情 " << i << endl; } } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

<3>std::defer_lock
用这个defer_lock的前提，你不能自己先lock()，否则会报异常。
defer_lock的意思就是并没有给mutex加锁，初始化了一个没有加锁的mutex。
我们借着 defer_lock 的话题，来介绍一些 unique_lock 的重要成员函数。
三、unique_lock的成员函数
<1>lock() 加锁

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock guard_1(my_mutex_1, std::defer_lock); //没有加锁的my_mutex_1 guard_1.lock(); //我们不用自己unlock //拿到了锁 msgRecvQueue.push_back(i); // 假设这个数字i就是我收到的命令，直接弄到消息队列中 } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); //std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

<2>unlock()解锁

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock guard_1(my_mutex_1, std::defer_lock); //没有加锁的my_mutex_1 guard_1.lock(); //我们不用自己unlock //因为有一些非共享代码要处理 guard_1.unlock(); //处理一些非共享代码 guard_1.lock(); //拿到了锁 msgRecvQueue.push_back(i); // 假设这个数字i就是我收到的命令，直接弄到消息队列中 guard_1.unlock(); //画蛇添足，但也可以 } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); //std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

<3>try_lock()
尝试给互斥量加锁，如果拿不到锁，则返回false，如果拿到了锁，返回true，这个函数不阻塞的；

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock guard_1(my_mutex_1, std::defer_lock); //没有加锁的my_mutex_1 if (guard_1.try_lock()) { //拿到了锁 msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接弄到消息队列中 //其他处理代码； } else { //没拿到锁 cout << "inMsgRecvQueue()执行，但没有拿到锁，只能干点别的事情" << endl; } } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); //std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

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

class MA { public: //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { std::unique_lock guard_1(my_mutex_1); std::mutex* ptx = guard_1.release(); //现在你有责任自己解锁这个my_mutex_1； //拿到了锁 msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接弄到消息队列中 //其他处理代码； ptx->unlock(); //自己负责mutex的unlock了 } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); //std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }

为什么有时候需要 unlock()：因为你 lock 锁住的代码段越少，执行越快，整个程序运行效率越高。

有人也把锁头锁住的代码多少称为锁的粒度，粒度一般用粗细来描述
1>锁住的代码少，粒度细，执行效率高；
2>锁住的代码多，粒度粗，执行效率低；
要学会尽量选择适合粒度的代码进行保护，粒度太细，可能漏掉共享数据的保护，粒度太粗，影响效率。
选择合适的粒度，是高级程序员能力和实力的体现。

四、unique_lock所有权的传递mutex
std::unique_lock guard_1(my_mutex_1); 所有权概念
guard_1 拥有 my_mutex_1 的所有权。
guard_1 可以把自己对 mutex(my_mutex_1) 的所有权转移给其他的 unique_lock 对象;
所以，unique_lock 对象这个 mutex 的所有权是属于可以转移，但是不能复制。16章6、7节智能指针unique_ptr。
复制所有权是非法的。

std::unique_lock guard_1(my_mutex_1); std::unique_lock guard_2(guard_1); //复制所有权

【c++学习|17.6 unique_lock详解】所有权转移方式：
1>std::move
2>reutrn std::unique_lockstd::mutex

class MA { public: std::unique_lock rtn_unique_gurad() { std::unique_locktmpgurad(my_mutex_1); return tmpgurad; //从函数返回一个局部的unique_lock对象是可以的，十四章十四节讲解过移动构造函数。 //返回这种局部对象tmpgurad会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数 } //把收到的消息(玩家命令)放入到一个队列的线程 void inMsgRecvQueue() { for (int i = 0; i < 100000; ++i) { cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl; { //std::unique_lock guard_1(my_mutex_1); //std::unique_lock guard_2(std::move(guard_1)); //移动语义，现在相当于guard_2和my_mutex_1绑定到一起了。 //现在guard_1指向空，guard_2指向了my_mutex_1。std::unique_lock guard_2 = rtn_unique_gurad(); std::mutex* ptx = guard_2.release(); //现在你有责任自己解锁这个my_mutex_1；//拿到了锁 msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接弄到消息队列中 //其他处理代码； ptx->unlock(); //自己负责mutex的unlock了 } } } bool outMsgLUProc(int& command) { std::unique_lock sbguard1(my_mutex_1); //std::chrono::milliseconds dura(200); //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 = 0; for (int i = 0; i < 100000; ++i) { bool result = outMsgLUProc(command); if (result == true) { cout << "outMsgRecvQueue()执行，取出一个元素" << endl; //这里就考虑处理数据... //... } else { cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl; } } cout << "end" << endl; } private: list msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送的命令 mutex my_mutex_1; //创建了一个互斥量(一把锁头) //mutex my_mutex_2; //创建了一个互斥量(一把锁头) }; int main() { MA myobj; std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj); //第二个参数是引用,才能保证线程里用的是同一个对象 std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj); myOutMsgObj.join(); myInMsgObj.join(); cout << "main主函数执行结束" << endl; //最后执行这句，整个进程退出 return 0; }