std::unique_lock

Определён в заголовочном файле `<mutex>`
template< class Mutex > class unique_lock;		(начиная с C++11)

Класс unique_lock — это универсальная обёртка для владения мьютексом, поддерживающая отложенную блокировку, попытки блокировки с ограничением по времени, рекурсивную блокировку, передачу владения блокировкой и использование с условными переменными.

Класс unique_lock допускает перемещение, но не копирование — он удовлетворяет требованиям MoveConstructible и MoveAssignable, но не требованиям CopyConstructible или CopyAssignable.

Класс unique_lock удовлетворяет требованиям BasicLockable. Если Mutex удовлетворяет требованиям Lockable, unique_lock также удовлетворяет требованиям Lockable (например, может использоваться в std::lock); если Mutex удовлетворяет требованиям TimedLockable, unique_lock также удовлетворяет требованиям TimedLockable.

Параметры шаблона

Mutex

тип блокируемого мьютекса. Тип должен удовлетворять требованиям BasicLockable

Вложенные типы

Тип	Определение
`mutex_type`	`Mutex`

Функции-члены

(конструктор)	создаёт `unique_lock`, при необходимости блокируя (то есть получая владение) переданный мьютекс (открытая функция-член)
(деструктор)	разблокирует связанный мьютекс (то есть освобождает владение им), если владеет им (открытая функция-член)
operator=	разблокирует мьютекс (то есть освобождает владение им), если владеет им, и получает владение другим мьютексом (открытая функция-член)
Блокировка
lock	блокирует связанный мьютекс (то есть получает владение им) (открытая функция-член)
try_lock	пытается заблокировать связанный мьютекс (то есть получить владение им), не блокируя выполнение (открытая функция-член)
try_lock_for	пытается заблокировать связанный мьютекс TimedLockable (то есть получить владение им) и возвращает управление, если мьютекс был недоступен в течение указанного промежутка времени (открытая функция-член)
try_lock_until	пытается заблокировать связанный мьютекс TimedLockable (то есть получить владение им) и возвращает управление, если мьютекс оставался недоступным до наступления указанного момента времени (открытая функция-член)
unlock	разблокирует связанный мьютекс (то есть освобождает владение им) (открытая функция-член)
Модификаторы
swap	обменивается состоянием с другим `std::unique_lock` (открытая функция-член)
release	отсоединяет связанный мьютекс, не разблокируя его (то есть не освобождая владение им) (открытая функция-член)
Наблюдатели
mutex	возвращает указатель на связанный мьютекс (открытая функция-член)
owns_lock	проверяет, владеет ли блокировка связанным мьютексом (то есть заблокировала ли его) (открытая функция-член)
operator bool	проверяет, владеет ли блокировка связанным мьютексом (то есть заблокировала ли его) (открытая функция-член)

Функции, не являющиеся членами

std::swap(std::unique_lock)

(C++11)

специализирует алгоритм std::swap
(шаблон функции)

Пример

#include <iostream>
#include <mutex>
#include <thread>

struct Box
{
    explicit Box(int num) : num_things{num} {}
    
    int num_things;
    std::mutex m;
};

void transfer(Box& from, Box& to, int num)
{
    // don't actually take the locks yet
    std::unique_lock lock1{from.m, std::defer_lock};
    std::unique_lock lock2{to.m, std::defer_lock};
    
    // lock both unique_locks without deadlock
    std::lock(lock1, lock2);
    
    from.num_things -= num;
    to.num_things += num;
    
    // “from.m” and “to.m” mutexes unlocked in unique_lock dtors
}

int main()
{
    Box acc1{100};
    Box acc2{50};
    
    std::thread t1{transfer, std::ref(acc1), std::ref(acc2), 10};
    std::thread t2{transfer, std::ref(acc2), std::ref(acc1), 5};
    
    t1.join();
    t2.join();
    
    std::cout << "acc1: " << acc1.num_things << "\n"
                 "acc2: " << acc2.num_things << '\n';
}

Вывод:

acc1: 95
acc2: 55

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

DR	Применяется к	Опубликованное поведение	Корректное поведение
LWG 2981	C++17	было предоставлено избыточное руководство по выводу типов из `unique_lock<Mutex>`	удалено

См. также

lock (C++11)	блокирует указанные мьютексы и ожидает, если какой-либо из них недоступен (шаблон функции)
lock_guard (C++11)	представляет собой обёртку для владения мьютексом, строго ограниченную областью действия (шаблон класса)
scoped_lock (C++17)	обёртка RAII для нескольких мьютексов, предотвращающая взаимную блокировку (шаблон класса)
mutex (C++11)	предоставляет базовые средства взаимного исключения (класс)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/thread/unique_lock