Namespaces
Variants

std::unique_lock<Mutex>:: unique_lock

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(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++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
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 ( ) 无阻塞地锁定关联的互斥量。若 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 <mutex>
#include <thread>
#include <utility>
#include <vector>
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 << "和" << a + 1 << "的斐波那契数："
              << b << " 和 " << c << '\n';
}

输出： 

12和13的斐波那契数：144 和 233