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 для unique_lock
(шаблон функции)

Пример

#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/w/cpp/thread/unique_lock