Библиотека поддержки параллелизма (начиная с C++11)
C++ включает встроенную поддержку потоков, атомарных операций, взаимного исключения, условных переменных и будущих результатов.
Потоки
Потоки позволяют программам выполняться на нескольких ядрах процессора.
Определено в заголовке <thread> |
|
|---|---|
|
(C++11) | управляет отдельным потоком (класс) |
|
(C++20) |
std::thread с поддержкой автоматического присоединения и отмены (класс) |
Функции управления текущим потоком |
|
Определено в пространстве имён this_thread |
|
|
(C++11) | предлагает реализации перераспределить выполнение потоков (функция) |
|
(C++11) | возвращает идентификатор текущего потока (функция) |
|
(C++11) | приостанавливает выполнение текущего потока на заданный промежуток времени (функция) |
|
(C++11) | приостанавливает выполнение текущего потока до заданного момента времени (функция) |
Кооперативная отмена (начиная с C++20)
Компоненты источник остановки, токен остановки и обратный вызов остановки можно использовать для асинхронного запроса на своевременное прекращение выполнения операции, обычно потому, что её результат больше не требуется. Такой запрос называется запросом остановки.
Эти компоненты задают семантику совместного доступа к состоянию остановки. Любой объект, моделирующий один из этих компонентов и ссылающийся на то же состояние остановки, является соответствующим источником остановки, токеном остановки или обратным вызовом остановки.
| Концепты | (начиная с C++26) |
Они предназначены:
- для кооперативной отмены выполнения, например в случае
std::jthread, - для прерывания функций ожидания
std::condition_variable_any,
| (начиная с C++26) |
- или для пользовательской реализации управления выполнением.
На самом деле, их даже не обязательно использовать для «остановки» чего-либо: например, их можно использовать как потокобезопасный триггер однократного вызова функции.
Определено в заголовке <stop_token> |
|
|---|---|
Типы токенов остановки |
|
|
(C++20) | интерфейс для проверки того, был ли сделан запрос на отмену std::jthread (класс) |
|
(C++26) | предоставляет интерфейс токена остановки, который гарантирует, что остановка невозможна и не запрашивалась (класс) |
|
(C++26) | токен остановки, ссылающийся на состояние остановки связанного с ним объекта std::inplace_stop_source (класс) |
Типы источников остановки |
|
|
(C++20) | класс, представляющий запрос на остановку одного или нескольких std::jthread (класс) |
|
(C++26) | stoppable-source, являющийся единственным владельцем состояния остановки (класс) |
Типы обратных вызовов остановки |
|
|
(C++20) | интерфейс для регистрации обратных вызовов при отмене std::jthread (шаблон класса) |
|
(C++26) | обратный вызов остановки для std::inplace_stop_token (шаблон класса) |
|
(C++26) | получает тип обратного вызова для заданного типа токена остановки (шаблон псевдонима) |
Концепты (начиная с C++20) |
|
|
(C++26) | задаёт базовый интерфейс токенов остановки, позволяющий проверять наличие запросов остановки и возможность запроса остановки (концепт) |
|
(C++26) | задаёт токен остановки, который не допускает остановку (концепт) |
|
(C++26) | задаёт тип, являющийся фабрикой связанных токенов остановки, для которого можно сделать запрос остановки (концепт только для пояснения*) |
|
(C++26) | задаёт интерфейс для регистрации обратных вызовов с заданным типом токена остановки (концепт только для пояснения*) |
Доступ к размеру кэша (начиная с C++17)
Определено в заголовке <new> |
|
|---|---|
|
(C++17) | минимальное смещение для предотвращения ложного совместного использования максимальное смещение для повышения эффективности совместного использования (константа) |
Атомарные операции
Эти компоненты предназначены для выполнения мелкозернистых атомарных операций, позволяющих создавать конкурентные программы без блокировок. Каждая атомарная операция неделима относительно любой другой атомарной операции, затрагивающей тот же объект. Атомарные объекты не подвержены гонкам данных.
Определено в заголовке <atomic> |
|
|---|---|
Атомарные типы |
|
|
(C++11) | шаблон класса atomic и его специализации для типов bool, целочисленных, с плавающей точкой(начиная с C++20) и указателей (шаблон класса) |
|
(C++20) | предоставляет атомарные операции над неатомарными объектами (шаблон класса) |
Операции над атомарными типами |
|
|
(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++11) | заменяет атомарный объект результатом побитовой операции исключающее ИЛИ с неатомарным аргументом и получает предыдущее значение атомарного объекта (шаблон функции) |
|
(C++26)(C++26) | заменяет атомарный объект результатом std::max с неатомарным аргументом и получает предыдущее значение атомарного объекта (шаблон функции) |
|
(C++26)(C++26) | заменяет атомарный объект результатом std::min с неатомарным аргументом и получает предыдущее значение атомарного объекта (шаблон функции) |
|
(C++20)(C++20) | блокирует поток до получения уведомления и изменения атомарного значения (шаблон функции) |
|
(C++20) | уведомляет поток, заблокированный в atomic_wait (шаблон функции) |
|
(C++20) | уведомляет все потоки, заблокированные в atomic_wait (шаблон функции) |
Тип флага и операции |
|
|
(C++11) | неблокирующий атомарный логический тип (класс) |
|
(C++11)(C++11) | атомарно устанавливает флаг в true и возвращает его предыдущее значение (функция) |
|
(C++11)(C++11) | атомарно устанавливает значение флага в false (функция) |
|
(C++20)(C++20) | атомарно возвращает значение флага (функция) |
|
(C++20)(C++20) | блокирует поток до получения уведомления и изменения флага (функция) |
|
(C++20) | уведомляет поток, заблокированный в atomic_flag_wait (функция) |
|
(C++20) | уведомляет все потоки, заблокированные в atomic_flag_wait (функция) |
Инициализация |
|
|
(C++11)(устарело в C++20) | неатомарная инициализация атомарного объекта, созданного конструктором по умолчанию (шаблон функции) |
|
(C++11)(устарело в C++20) | константная инициализация атомарной переменной со статической длительностью хранения (макрос функции) |
|
(C++11) | инициализирует std::atomic_flag значением false (макроконстанта) |
Порядок синхронизации памяти |
|
|
(C++11) | задаёт ограничения порядка доступа к памяти для указанной атомарной операции (перечисление) |
|
(C++11)(устарело в C++26) | удаляет указанный объект из дерева зависимостей std::memory_order_consume (шаблон функции) |
|
(C++11) | универсальная примитивная операция синхронизации барьера, зависящая от порядка доступа к памяти (функция) |
|
(C++11) | барьер между потоком и обработчиком сигнала, выполняемым в том же потоке (функция) |
Определено в заголовке <stdatomic.h> |
|
Макросы совместимости с C (начиная с C++23) |
|
|
(C++23) | макрос совместимости, обеспечивающий тождественность _Atomic(T) и std::atomic<T> (макрос функции) |
Ни макрос _Atomic, ни какие-либо объявления в глобальном пространстве имён, не являющиеся макросами, не предоставляются заголовками стандартной библиотеки C++, кроме <stdatomic.h>.
Взаимное исключение
Алгоритмы взаимного исключения предотвращают одновременный доступ нескольких потоков к общим ресурсам. Это предотвращает гонки данных и обеспечивает поддержку синхронизации между потоками.
Определено в заголовочном файле <mutex> |
|
|---|---|
|
(C++11) | предоставляет базовый механизм взаимного исключения (класс) |
|
(C++11) | предоставляет механизм взаимного исключения с блокировкой, ограниченной по времени (класс) |
|
(C++11) | предоставляет механизм взаимного исключения, который может рекурсивно блокироваться одним и тем же потоком (класс) |
|
(C++11) | предоставляет механизм взаимного исключения, который может рекурсивно блокироваться одним и тем же потоком и обеспечивает блокировку, ограниченную по времени (класс) |
Определено в заголовочном файле <shared_mutex> |
|
|
(C++17) | предоставляет механизм совместного взаимного исключения (класс) |
|
(C++14) | предоставляет механизм совместного взаимного исключения с блокировкой, ограниченной по времени (класс) |
Обобщённое управление мьютексами |
|
Определено в заголовочном файле <mutex> |
|
|
(C++11) | реализует обёртку для владения мьютексом, строго ограниченную областью видимости (шаблон класса) |
|
(C++17) | обёртка RAII для нескольких мьютексов, предотвращающая взаимную блокировку (шаблон класса) |
|
(C++11) | реализует перемещаемую обёртку для владения мьютексом (шаблон класса) |
|
(C++14) | реализует перемещаемую обёртку для владения мьютексом совместного доступа (шаблон класса) |
|
(C++11) | теги для указания стратегии блокировки (тег) |
Обобщённые алгоритмы блокировки |
|
|
(C++11) | пытается получить владение мьютексами посредством повторных вызовов try_lock (шаблон функции) |
|
(C++11) | блокирует указанные мьютексы и ожидает, если хотя бы один из них недоступен (шаблон функции) |
Однократный вызов |
|
|
(C++11) | вспомогательный объект, гарантирующий, что call_once вызовет функцию только один раз (класс) |
|
(C++11) | вызывает функцию только один раз, даже если она вызвана из нескольких потоков (шаблон функции) |
Условные переменные
Условная переменная — это примитив синхронизации, позволяющий нескольким потокам обмениваться данными друг с другом. Она позволяет некоторому числу потоков ожидать (возможно, с ограничением по времени) уведомления от другого потока о том, что они могут продолжить выполнение. Условная переменная всегда связана с мьютексом.
Определено в заголовочном файле <condition_variable> |
|
|---|---|
|
(C++11) | предоставляет условную переменную, связанную с std::unique_lock (класс) |
|
(C++11) | предоставляет условную переменную, связанную с любым типом блокировки (класс) |
|
(C++11) | планирует вызов notify_all после полного завершения этого потока (функция) |
|
(C++11) | перечисляет возможные результаты ожидания с ограничением по времени на условных переменных (перечисление) |
Семафоры (начиная с C++20)
Семафор — это лёгкий примитив синхронизации, используемый для ограничения параллельного доступа к общему ресурсу. Если подходят оба варианта, семафор может быть эффективнее условной переменной.
Определено в заголовочном файле <semaphore> |
|
|---|---|
|
(C++20) | семафор, моделирующий неотрицательное количество ресурсов (шаблон класса) |
|
(C++20) | семафор, имеющий только два состояния (псевдоним типа) |
Защёлки и барьеры (начиная с C++20)
Защёлки и барьеры — это механизмы координации потоков, позволяющие любому числу потоков блокироваться до прихода ожидаемого числа потоков. Защёлку нельзя использовать повторно, а барьер можно использовать многократно.
Определено в заголовочном файле <latch> |
|
|---|---|
|
(C++20) | одноразовый барьер потоков (класс) |
Определено в заголовочном файле <barrier> |
|
|
(C++20) | повторно используемый барьер потоков (шаблон класса) |
Фьючерсы
Стандартная библиотека предоставляет средства для получения значений, возвращаемых асинхронными задачами (то есть функциями, запущенными в отдельных потоках), и перехвата исключений, выбрасываемых ими. Эти значения передаются через общее состояние, в которое асинхронная задача может записать возвращаемое значение или сохранить исключение и которое могут просматривать, ожидать и иным образом использовать другие потоки, содержащие экземпляры std::future или std::shared_future, ссылающиеся на это общее состояние.
Определено в заголовочном файле <future> |
|
|---|---|
|
(C++11) | сохраняет значение для асинхронного получения (шаблон класса) |
|
(C++11) | упаковывает функцию, чтобы сохранить её возвращаемое значение для асинхронного получения (шаблон класса) |
|
(C++11) | ожидает значение, устанавливаемое асинхронно (шаблон класса) |
|
(C++11) | ожидает значение (на которое могут ссылаться другие фьючерсы), устанавливаемое асинхронно (шаблон класса) |
|
(C++11) | выполняет функцию асинхронно (возможно, в новом потоке) и возвращает std::future, который будет содержать результат (шаблон функции) |
|
(C++11) | задаёт политику запуска для std::async (перечисление) |
|
(C++11) | задаёт результаты ожидания с ограничением по времени, выполняемого для std::future и std::shared_future (перечисление) |
Ошибки фьючерсов |
|
|
(C++11) | сообщает об ошибке, связанной с фьючерсами или обещаниями (класс) |
|
(C++11) | определяет категорию ошибок фьючерсов (функция) |
|
(C++11) | определяет коды ошибок фьючерсов (перечисление) |
Безопасное освобождение памяти (начиная с C++26)
Методы безопасного освобождения памяти чаще всего используются для простого устранения гонок между доступом и удалением.
Механизм Read-Copy-Update |
|
Определено в заголовочном файле <rcu> |
|
|---|---|
|
(C++26) | позволяет защитить объект с помощью RCU (шаблон класса) |
|
(C++26) | предоставляет области защиты RCU (класс) |
|
(C++26) | возвращает ссылку на объект статической длительности хранения типа std::rcu_domain (функция) |
|
(C++26) | блокирует выполнение до снятия блокировки области защиты в домене RCU (функция) |
|
(C++26) | может выполнить запланированные операции в домене RCU и блокирует выполнение до завершения всех предшествующих операций (функция) |
|
(C++26) | планирует выполнение указанной функции в домене RCU, при необходимости выделяет память и запускает запланированные операции (шаблон функции) |
Указатели опасности |
|
Определено в заголовочном файле <hazard_pointer> |
|
|
(C++26) | позволяет защищать объект с помощью указателя опасности (шаблон класса) |
|
(C++26) | указатель с одним писателем и несколькими читателями, которым в каждый момент времени может владеть не более одного потока (класс) |
|
(C++26) | создаёт указатель опасности (функция) |
См. также
| Документация по C для библиотеки поддержки параллелизма |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/atomic
