std::mutex

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

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

mutex обеспечивает семантику эксклюзивного невложенного владения:

Вызывающий поток владеет mutex с момента успешного вызова lock или try_lock до вызова unlock.
Пока поток владеет mutex, все остальные потоки будут заблокированы (при вызове lock) или получат значение возврата false (при вызове try_lock), если попытаются получить владение mutex.
Вызывающий поток не должен владеть mutex до вызова lock или try_lock.

Поведение программы не определено, если mutex уничтожается, пока им всё ещё владеет какой-либо поток, или если поток завершается, владея mutex. Класс mutex удовлетворяет всем требованиям Mutex и StandardLayoutType.

std::mutex нельзя копировать или перемещать.

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

Имя	Определение
`native_handle_type` (необязательный*)	определяется реализацией

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

(конструктор)	создаёт мьютекс (открытая функция-член)
(деструктор)	уничтожает мьютекс (открытая функция-член)
operator= [удалён]	копирующее присваивание недоступно (открытая функция-член)
Блокировка
lock	блокирует мьютекс; если мьютекс недоступен, блокирует поток (открытая функция-член)
try_lock	пытается заблокировать мьютекс и возвращает управление, если мьютекс недоступен (открытая функция-член)
unlock	снимает блокировку мьютекса (открытая функция-член)
Нативный дескриптор
native_handle	возвращает нативный дескриптор нижележащей реализации, определяемый реализацией (открытая функция-член)

Примечания

К std::mutex обычно не обращаются напрямую: std::unique_lock, std::lock_guard или std::scoped_lock(начиная с C++17) управляют блокировкой, обеспечивая более безопасную обработку исключений.

Пример

В этом примере показано, как mutex можно использовать для защиты std::map, совместно используемого двумя потоками.

#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <thread>

std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;

void save_page(const std::string& url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
    
    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}

int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
    
    // safe to access g_pages without lock now, as the threads are joined
    for (const auto& [url, page] : g_pages)
        std::cout << url << " => " << page << '\n';
}

Вывод:

http://bar => fake content
http://foo => fake content

См. также

recursive_mutex (C++11)	предоставляет механизм взаимного исключения, который один и тот же поток может блокировать рекурсивно (класс)
lock_guard (C++11)	реализует оболочку владения мьютексом, строго привязанную к области видимости (шаблон класса)
unique_lock (C++11)	реализует перемещаемую оболочку владения мьютексом (шаблон класса)
scoped_lock (C++17)	оболочка RAII для нескольких мьютексов, предотвращающая взаимную блокировку (шаблон класса)
condition_variable (C++11)	предоставляет условную переменную, связанную с `std::unique_lock` (класс)

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