std::unique_lock<Mutex>::unique_lock

< cpp‎ | thread‎ | unique lock
 
C++
 
线程支持库
线程
(C++11)
(C++20)
(C++20)
(C++20)
(C++20)
(C++17)(C++17)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
(C++11)
互斥
(C++11)
(C++11)
(C++17)
通用锁管理
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
条件变量
(C++11)
(C++11)
(C++11)
(C++11)
信号量
(C++20)(C++20)
闩与屏障
(C++20)
(C++20)
future
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
 
std::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() 尝试锁定关联互斥而不阻塞。若当前线程已占有互斥则行为未定义，除非互斥是递归的。
6) 假定调用方线程已占有 m 。
7) 通过调用 m.try_lock_for(timeout_duration) 尝试锁定关联互斥。阻塞直至经过指定的 timeout_duration 或获得锁，之先到来者。可能阻塞长于 timeout_duration 。
8) 通过调用 m.try_lock_until(timeout_time) 尝试锁定关联互斥。阻塞直至抵达指定的 timeout_time 或获得锁，之先到来者。可能阻塞长于抵达 timeout_time 。

参数

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