发布时间：2023-03-19 09:00
一、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); //复制所有权
所有权转移方式：
1>std::move
2>reutrn std::unique_lockstd::mutex
class MA
{
public:
std::unique_lock rtn_unique_gurad()
{
std::unique_lock tmpgurad(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;
}