# std::unique_lock<Mutex>::unique_lock

< cpp‎ | thread‎ | unique lock

unique_lock() noexcept; | (1) | (C++11 起)
unique_lock( unique_lock&& other ) noexcept; | (2) | (C++11 起)
explicit unique_lock( mutex_type& m ); | (3) | (C++11 起)
unique_lock( mutex_type& m, std::defer_lock_t t ) noexcept; | (4) | (C++11 起)
unique_lock( mutex_type& m, std::try_to_lock_t t ); | (5) | (C++11 起)
unique_lock( mutex_type& m, std::adopt_lock_t t ); | (6) | (C++11 起)
template< class Rep, class Period > unique_lock( mutex_type& m, const std::chrono::duration<Rep,Period>& timeout_duration ); | (7) | (C++11 起)
template< class Clock, class Duration > unique_lock( mutex_type& m, const std::chrono::time_point<Clock,Duration>& timeout_time ); | (8) | (C++11 起)

构造 `unique_lock` ，可选地锁定提供的互斥。

1) 构造无关联互斥的 `unique_lock` 。
2) 移动构造函数。以 `other` 的内容初始化 `unique_lock` 。令 `other` 无关联互斥。
3-8) 构造以 `m` 为关联互斥的 `unique_lock` 。另外：
3) 通过调用 m.lock() 锁定关联互斥。
4) 不锁定关联互斥。
5) 通过调用 m.try_lock() 尝试锁定关联互斥而不阻塞。若 `Mutex` 不满足可锁定 (Lockable) 则行为未定义。
6) 假定调用方线程已保有 `m` 上的非共享锁（即由 `lock`、 `try_lock`、 `try_lock_for` 或 `try_lock_until` 取得的锁）。若非如此则行为未定义。
7) 通过调用 m.try_lock_for(timeout_duration) 尝试锁定关联互斥。阻塞到经过指定的 `timeout_duration` 或获得锁这两个事件的先到来者为止。可能阻塞长于 `timeout_duration` 。若 `Mutex` 不满足可定时锁定 (TimedLockable) 则行为未定义。
8) 通过调用 m.try_lock_until(timeout_time) 尝试锁定关联互斥。阻塞到抵达指定的 `timeout_time` 或获得锁这两个事件的先到来者为止。可能阻塞长于抵达 `timeout_time` 。若 `Mutex` 不满足可定时锁定 (TimedLockable) 则行为未定义。

### 参数

other | - | 用以初始化状态的另一 `unique_lock`
m | - | 与锁关联且可选的获得所有权的互斥
t | - | 用于选择拥有不同锁定策略的构造函数的标签参数
timeout_duration | - | 要阻塞的最大时长
timeout_time | - | 要阻塞到的最大时间点

### 示例

    #include <iostream>
    #include <thread>
    #include <vector>
    #include <mutex>
    std::mutex m_a, m_b, m_c;
    int a, b, c = 1;
    void update()
    {
        {   // 注意：可用 std::lock_guard 或 atomic<int> 代替
            std::unique_lock<std::mutex> lk(m_a);
            a++;
        }

        { // 注意：细节和替代品见 std::lock 及 std::scoped_lock
          std::unique_lock<std::mutex> lk_b(m_b, std::defer_lock);
          std::unique_lock<std::mutex> lk_c(m_c, std::defer_lock);
          std::lock(lk_b, lk_c);
          b = std::exchange(c, b+c);
       }
    }

    int main()
    {
      std::vector<std::thread> threads;
      for (unsigned i = 0; i < 12; ++i)
        threads.emplace_back(update);

      for (auto& i: threads)
        i.join();

      std::cout << a << "'th and " << a+1 << "'th Fibonacci numbers: "
                << b << " and " << c << '\n';
    }

输出：

    12'th and 13'th Fibonacci numbers: 144 and 233