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) Конструктор перемещения. Инициализирует unique_lock содержимым other . Оставляет other без связанного мьютекса.
3-8) Создает unique_lock с m в качестве связанного мьютекса. Дополнительно:
3) Блокирует связанный мьютекс, вызывая m. lock ( ) .
4) Не блокирует связанный мьютекс.
5) Пытается заблокировать связанный мьютекс без блокировки, вызывая m. try_lock ( ) . Поведение не определено, если Mutex не удовлетворяет требованиям Lockable .
6) Предполагается, что вызывающий поток уже удерживает неразделяемую блокировку (т.е. блокировку, полученную с помощью lock , try_lock , try_lock_for , или try_lock_until ) на m . Поведение не определено, если это не так.
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