Namespaces
Variants

Concurrency support library (since C++11)

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)

C++ включает встроенную поддержку потоков, атомарных операций, взаимных исключений, условных переменных и фьючерсов.

Содержание

Потоки

Потоки позволяют программам выполняться на нескольких ядрах процессора.

Определено в заголовочном файле <thread>
(C++11)
управляет отдельным потоком выполнения
(класс)
(C++20)
std::thread с поддержкой автоматического присоединения и отмены
(класс)
Функции управления текущим потоком
Определено в пространстве имен this_thread
(C++11)
предлагает реализации перепланировать выполнение потоков
(функция)
(C++11)
возвращает идентификатор текущего потока
(функция)
(C++11)
останавливает выполнение текущего потока на указанный промежуток времени
(функция)
(C++11)
останавливает выполнение текущего потока до указанного момента времени
(функция)

Кооперативная отмена (since C++20)

Компоненты stop source , stop token и stop callback могут использоваться для асинхронного запроса остановки выполнения операции своевременным образом, обычно потому что результат больше не требуется. Такой запрос называется stop request .

Эти компоненты определяют семантику совместного доступа к stop state . Любой объект, моделирующий любой из этих компонентов, который ссылается на то же состояние остановки, является соответствующим ассоциированным источником остановки, токеном остановки или обратным вызовом остановки соответственно.

Концепты stoppable-source , stoppable_token и stoppable-callback-for определяют требуемый синтаксис и модельную семантику источника остановки, токена остановки и колбэка остановки соответственно.

(since C++26)

Они разработаны:

  • для выполнения остановленного завершения асинхронной операции, созданной с помощью execution::connect ,
(начиная с 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)
определяет интерфейс для регистрации колбэков с заданным типом стоп-токена
( концепт только для демонстрации* )

Доступ к размеру кэша (since C++17)

Определено в заголовке <new>
(C++17)
минимальное смещение для избежания ложного разделения
максимальное смещение для содействия истинному разделению
(константа)

Атомарные операции

Эти компоненты предоставляются для тонко-гранулированных атомарных операций, позволяющих реализовывать lockless параллельное программирование. Каждая атомарная операция является неделимой по отношению к любой другой атомарной операции, затрагивающей тот же объект. Атомарные объекты свободны от состояний гонки данных .

Определено в заголовочном файле <atomic>
Атомарные типы
(C++11)
шаблон класса atomic и специализации для bool, целочисленных, чисел с плавающей запятой, (since 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) (deprecated in C++20)
неатомарная инициализация объекта atomic, созданного конструктором по умолчанию
(function template)
(C++11) (deprecated in C++20)
константная инициализация атомарной переменной со статической продолжительностью хранения
(макрос функции)
(C++11)
инициализирует std::atomic_flag значением false
(макроконстанта)
Порядок синхронизации памяти
(C++11)
определяет ограничения порядка памяти для данной атомарной операции
(enum)
(C++11) (deprecated in 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)
перечисляет возможные результаты ожидания с таймаутом на переменных условия
(перечисление)

Семафоры (since C++20)

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

Определено в заголовке <semaphore>
(C++20)
семафор, моделирующий неотрицательный счётчик ресурсов
(шаблон класса)
(C++20)
семафор, имеющий только два состояния
(определение типа)

Защелки и барьеры (since C++20)

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

Определено в заголовочном файле <latch>
(C++20)
однократный барьер для потоков
(класс)
Определено в заголовочном файле <barrier>
(C++20)
многократный барьер для потоков
(шаблон класса)

Фьючерсы

Стандартная библиотека предоставляет средства для получения возвращаемых значений и перехвата исключений, генерируемых асинхронными задачами (т.е. функциями, запущенными в отдельных потоках). Эти значения передаются через общее состояние , в котором асинхронная задача может записать свое возвращаемое значение или сохранить исключение, и которое может быть исследовано, ожидаемо и иным образом использовано другими потоками, содержащими экземпляры std::future или std::shared_future , ссылающиеся на это общее состояние.

Определено в заголовочном файле <future>
(C++11)
хранит значение для асинхронного получения
(шаблон класса)
(C++11)
упаковывает функцию для хранения её возвращаемого значения для асинхронного получения
(шаблон класса)
(C++11)
ожидает значение, которое устанавливается асинхронно
(шаблон класса)
(C++11)
ожидает значение (возможно, ссылаемое другими future), которое устанавливается асинхронно
(шаблон класса)
(C++11)
запускает функцию асинхронно (потенциально в новом потоке) и возвращает std::future , который будет содержать результат
(шаблон функции)
(C++11)
определяет политику запуска для std::async
(перечисление)
(C++11)
определяет результаты временных ожиданий, выполняемых на std::future и std::shared_future
(перечисление)
Ошибки future
(C++11)
сообщает об ошибке, связанной с future или promise
(класс)
(C++11)
идентифицирует категорию ошибок future
(функция)
(C++11)
идентифицирует коды ошибок future
(перечисление)

Безопасная рекламация (since 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)
позволяет объекту быть защищаемым с помощью hazard-указателей
(шаблон класса)
(C++26)
указатель с одним писателем и многими читателями, который может принадлежать не более чем одному потоку в любой момент времени
(класс)
(C++26)
создает hazard-указатель
(функция)

Смотрите также

C documentation for Concurrency support library