提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

现代的计算机性能很强大，可以实现多线程并发。随之而来引入了另一个问题：“数据竞争”，这个问题是并发编程必须面对的。还有一种情形，当我们需要同时满足获取多个锁才能进行下一步操作该怎么办呢？

最简单的方法是定义3个mutex，依次lock()，当全部满足的时候再进行下一步。看起来似乎可行，但是对于场景比较复杂的情况可能引来一个非常危险的后果“死锁”：想想那样一种场景，你所需要的锁也同样被其他很多线程需要，随着锁的数量增加，“死锁”的概率随之增大，无形之中增加了风险。

也许你的编程能力非常强，但是这种隐藏起来的危害或许总有让你眼前一亮的时候！庆幸的是C++标准给我们提供了一个现成的方法，请往下看。

一、unique_lock是什么？

简而言之，unique_lock是C++标准为mutex包装的一个RAII风格（资源获取即初始化技术）对象，能够将“锁资源”自动管理起来，减少程序员的压力和出错的可能。

二、unique_lock使用

1.简单使用

代码如下（示例）：

#include <iostream>
#include <mutex>

using namespace std;

void test_1(){
	mutex m;
    unique_lock<mutex> ul{m};
    //你的操作
}

上面的代码是最简单的用法，unique_lock对象创建的时候就会立刻获取锁，一旦拿到锁就可以进行你自己的操作了。不用手动调用lock()，一旦出了作用域就自动执行unlock()。

看下源代码片段：

      explicit unique_lock(mutex_type& __m)
      : _M_device(std::__addressof(__m)), _M_owns(false)
      {
	lock();
	_M_owns = true;
      }

lock()放在了构造函数里面，一旦获取到锁立即完成构造进行下一步。记着一个重要的变量：_M_owns，一会我们还会遇到。

看下析构函数：

      ~unique_lock()
      {
	if (_M_owns)
	  unlock();
      }

出了作用域unique_lock对象就自动析构了，顺便unlock()。这个地方有前提条件：注意刚才说的那个变量：_M_owns，只有它为true才会自动unlock()，如果是false，unlock()就不会自动调用了，这个后面再说。

简而言之，你通过最普通的那个构造函数（test_1()）创建的unique_lock对象会自动上锁+解锁，全程不需要程序员参与，大多数场景下你用的是这个。

2.多重锁

终于还是到了这篇文章的重头戏，多重锁机制适合于一种更复杂的场景：你同时需要多个锁的排他权才能进行下一步。这里演示同时获取3个互斥锁的场景。

代码如下（示例）：

#include <iostream>
#include <mutex>

using namespace std;

void test_2(){
    mutex m1;
    mutex m2;
    mutex m3;
    unique_lock<mutex> ul1{m1,defer_lock_t{}};
    unique_lock<mutex> ul2{m2,defer_lock_t{}};
    unique_lock<mutex> ul3{m3,defer_lock_t{}};
    lock(ul1,ul2,ul3);
    //你的操作
}

这里使用了双参数的构造函数，defer_lock_t的意思是延时加锁（暂不加锁）。

请看源代码片段：

      unique_lock(mutex_type& __m, defer_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(false)
      { }

仔细观察可以发现不同，跟上面的简单用法相比，函数体里面没有lock()，而且_M_owns初始化成false，记住这两个关键操作，后面会讲到。

所谓延时加锁的目的就是为了后面的那一步：统一加锁，也就是代码里的lock(ul1,ul2,ul3);这个函数不是unique_lock的成员函数，而是在这个头文件里面。

请看源代码片段：

  template<typename _L1, typename _L2, typename... _L3>
    void
    lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {
      while (true)
        {
          using __try_locker = __try_lock_impl<0, sizeof...(_L3) != 0>;
          unique_lock<_L1> __first(__l1);
          int __idx;
          auto __locks = std::tie(__l2, __l3...);
          __try_locker::__do_try_lock(__locks, __idx);
          if (__idx == -1)
            {
              __first.release();
              return;
            }
        }
    }

这个函数是可变参数模板，理论上支持不限制的锁，但是一般能同时使用3个以上的锁的场景并不会一直有。

多提一句，我上面写的test_2()函数有一个bug，细心的人可能已经发现了：只有lock()没有unlock()，原因很简单，使用多重锁必须程序员手动unlock()，因为_M_owns是false，所以unique_lock析构的时候不会调用unlock()。接下来我们完善下刚才的test_2()推出test_3()。

请看代码片段：

#include <iostream>
#include <mutex>

using namespace std;

void test_3(){
    mutex m1;
    mutex m2;
    mutex m3;
    unique_lock<mutex> ul1{m1,defer_lock_t{}};
    unique_lock<mutex> ul2{m2,defer_lock_t{}};
    unique_lock<mutex> ul3{m3,defer_lock_t{}};
    lock(ul1,ul2,ul3);
    //你的操作
    ul1.unlock();
    ul2.unlock();
    ul3.unlock();
}

总结

1、使用方法比较简单，使用RAII技术加持几乎不会出错