std::unique_lock<Mutex>::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

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

成员函数
unique_lock::unique_lock
unique_lock::~unique_lock
unique_lock::operator=
锁定
unique_lock::lock
unique_lock::try_lock
unique_lock::try_lock_for
unique_lock::try_lock_until
unique_lock::unlock
修改器
unique_lock::swap
unique_lock::release
观察器
unique_lock::mutex
unique_lock::owns_lock
unique_lock::operator bool
非成员函数
std::swap

std::unique_lock<Mutex>::unique_lock

参数

示例

导航