命名空间
变体
操作

std::unique_lock<Mutex>::unique_lock

来自 cppreference.cn
< cpp‎ | thread‎ | unique lock
 
 
并发支持库
线程
(C++11)
(C++20)
this_thread 命名空间
(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++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
危险指针
原子类型
(C++11)
(C++20)
原子类型的初始化
(C++11)(C++20 中已弃用)
(C++11)(C++20 中已弃用)
内存排序
(C++11)(C++26 中已弃用)
原子操作的自由函数
原子标志的自由函数
 
 
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 上的非共享锁(即通过 locktry_locktry_lock_fortry_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,则行为未定义。

[编辑] 参数

其他 - 另一个 unique_lock,用于初始化状态
m - 要与锁关联并可选地获取所有权的互斥体
t - 用于选择不同锁定策略的构造函数的标签参数
timeout_duration - 最大阻塞持续时间
timeout_time - 最大阻塞时间点

[编辑] 示例

#include <iostream>
#include <mutex>
#include <thread>
#include <utility>
#include <vector>
 
std::mutex m_a, m_b, m_c;
int a, b, c = 1;
 
void update()
{
    {   // Note: std::lock_guard or atomic<int> can be used instead
        std::unique_lock<std::mutex> lk(m_a);
        ++a;
    }
 
    {   // Note: see std::lock and std::scoped_lock for details and alternatives
        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