C++11并发与多线程笔记（6） unique_lock（类模板）详解

第六节 unique_lock（类模板）详解

一.unique_lock取代lock_guard

• unique_lock是个类模板，工作中一般用lock_guard就足够了（推荐使用）；
• unique_lock也是在构造函数里lock（），在析构函数里unlock（），这点和lockl_guard是一样的
• unique_lock比lock_guard灵活很多（多出来很多用法），但代价是效率差一点，内存占用多一点

二.unique_lock的第二个参数

2.1 std::adopt_lock：

• 表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。
• 前提是：必须已经提前lock成功了才能用这个标记量，否则会报异常
• lock_guard中也可以用这个参数

mutex.lock();
std::unique_lock<std::mutex> sbguard(mutex,std::adopt_lock);

其他

std::chrono::milliseconds dura(20000);//20000ms=20s
std::this_thread::sleep_for(dura);//休息一定时长

2.2 std::try_to_lock：

• 尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
• 使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
• 前提：不能提前lock(); 否则是导致程序卡死
• owns_locks()方法判断是否拿到锁，如拿到返回true

if(sbguard.owns_lock())
{
//拿到了锁
}
else
{
//只能干点别的事
}

2.3 std::defer_lock：

• 前提：不能提前lock，否则会报异常
• defer_lock的意思是并没有给mutex加锁：是初始化了一个没有加锁的mutex
• 不给它加锁的目的是以后可以调用unique_lock的一些重要成员函数

三.unique_lock的成员函数（前三个与std::defer_lock联合使用）

3.1 lock()：加锁

unique_lock<mutex> myUniLock(myMutex， defer_lock);//没有加锁的myMutex
myUniLock.lock();//加锁
//再2执行共享代码

不用自己unlock(); unique_lock就自动解锁绑定的myMutex

3.2 unlock()：解锁

unique_lock<mutex> myUniLock(myMutex， defer_lock);
myUniLock.lock();
//处理一些共享代码
myUniLock.unlock();
//处理一些非共享代码
myUniLock.lock();
//处理一些共享代码

因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再lock()。
如果最后还unlock，那就是画蛇添足，因为unique_lock会检查是否unlock，如果没有unlock会自动unlock，如果已经unlock了，就不会再unlock了

3.3 try_lock()：

• 尝试给互斥量加锁
• 如果拿不到锁，返回false，否则返回true。
• 和try_to_lock比较类似

3.4 release()：

• 返回它所管理的mutex对象指针，并释放所有权，也就是说这个unique_lock和mutex不再有关系
• 严格区分unlock（）和release（）的区别，不要混淆

std::unique_lock <std::mutex> sbguard(mymutex);
std::timed_mutex *ptx = sbguard.release();//这个指针指向的是mymutex对象，现在有责任自己解锁这个mymutex了
//...
ptx->unlock();//自己负责unlock了

• 相当于把mymutex和sbguard绑定在了一起，release()就是解除绑定，返回它所管理的mutex对象的指针，并释放所有权
• 如果解除了绑定，那最后的unlock就要自己来了
• 所有权由ptx接管，如果原来mutex对象处理加锁状态，就需要ptx在以后进行解锁了。

其他：
lock的代码段越少，执行越快，整个程序的运行效率越高。
有人也把锁头锁住的代码的多少，称为锁的粒度，粒度一般用粗细来描述

• a.锁住的代码少，叫做粒度细，执行效率高；
• b.锁住的代码多，叫做粒度粗，执行效率低；

要学会尽量选择合适粒度的代码进行保护，粒度太细，可能漏掉共享数据的保护，粒度太粗，影响效率。高级程序员的能力的体现。

四.unique_lock所有权的传递

• std::unique_lock < std::mutex > sbguard(mymutex);
  把mymutex和sbguard绑定在了一起，也就是sbguard拥有myMutex的所有权
• sbguard可以把自己对mutex的所有权转移给其他的unique_lock对象
• 这个所有权 可以转移 但是不能复制，和智能指针类似

4.1 使用move转移所有权

std::unique_lock <std::mutex> sbguard1(mymutex);
std::unique_lock <std::mutex> sbguard2(std::move(sbguard1));//移动语义，现在相当于sbguard2和mymutex绑定在一起了，sbguard1指向空，sbguard2指向了mymutex

可以F9打断点去看 所有权

4.2 在函数中return一个临时变量，也可以实现所有权转移

//函数：
std::unique_lock<std::mutex> aFunction()
{
    std::unique_lock<std::mutex> tmpguard(myMutex);
    //移动构造函数那里讲从函数返回一个局部的unique_lock对象是可以的
    //返回这种局部对象会导致系统生成临时的unique_lock对象，并调用unique_lock的移动构造函数
    return tmpguard;//返回局部unique_lock对象
}
//调用时：
std::unique_lock<std::mutex> sbguard = aFunction();//临时的temgurad绑定的myMutex就转移给sbguard了