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++ incluye soporte incorporado para hilos, operaciones atómicas, exclusión mutua, variables de condición y futuros.

Contenidos

Hilos

Los hilos permiten que los programas se ejecuten a través de varios núcleos de procesador.

Definido en el encabezado <thread>
(C++11)
gestiona un hilo separado
(clase)
(C++20)
std::thread con soporte para auto-unirse y cancelación
(clase)
Funciones que gestionan el hilo actual
Definido en el espacio de nombres this_thread
(C++11)
sugiere que la implementación reprograme la ejecución de hilos
(función)
(C++11)
devuelve el identificador del hilo actual
(función)
(C++11)
detiene la ejecución del hilo actual durante un período de tiempo especificado
(función)
(C++11)
detiene la ejecución del hilo actual hasta un punto temporal especificado
(función)

Cancelación cooperativa (since C++20)

Los componentes stop source , stop token , y stop callback pueden utilizarse para solicitar de manera asincrónica que una operación detenga su ejecución de manera oportuna, típicamente porque el resultado ya no es necesario. Tal solicitud se denomina stop request .

Estos componentes especifican la semántica de acceso compartido a un stop state . Cualquier objeto que modele cualquiera de estos componentes que se refiera al mismo stop state es un associated stop source, stop token, o stop callback, respectivamente.

Los conceptos stoppable-source , stoppable_token , y stoppable-callback-for especifican la sintaxis requerida y la semántica del modelo de fuente de parada, token de parada y callback de parada, respectivamente.

(desde C++26)

Están diseñados:

  • para realizar la finalización detenida de una operación asíncrona creada por execution::connect ,
(desde C++26)
  • o para una implementación personalizada de gestión de ejecución.

De hecho, ni siquiera necesitan ser utilizados para "detener" nada, sino que pueden usarse como un disparador de invocación única de función(es) seguro para hilos, por ejemplo.

Definido en el encabezado <stop_token>
Tipos de token de parada
(C++20)
una interfaz para consultar si se ha realizado una solicitud de cancelación de std::jthread
(clase)
(C++26)
proporciona una interfaz de token de parada donde la parada nunca es posible ni solicitada
(clase)
(C++26)
un token de parada que referencia el estado de parada de su objeto std::inplace_stop_source asociado
(clase)
Tipos de fuente de parada
(C++20)
clase que representa una solicitud para detener una o más std::jthread s
(clase)
(C++26)
una stoppable-source que es el único propietario del estado de parada
(clase)
Tipos de callback de parada
(C++20)
una interfaz para registrar callbacks en la cancelación de std::jthread
(plantilla de clase)
(C++26)
un callback de parada para std::inplace_stop_token
(plantilla de clase)
(C++26)
obtiene el tipo de callback para un tipo de token de parada dado
(plantilla de alias)
Conceptos (desde C++20)
(C++26)
especifica la interfaz básica de los tokens de parada que permite consultas para solicitudes de parada y si la solicitud de parada es posible
(concepto)
(C++26)
especifica un token de parada que no permite la detención
(concepto)
(C++26)
especifica que un tipo es una fábrica para tokens de parada asociados y se puede realizar una solicitud de parada sobre él
( concepto solo para exposición* )
(C++26)
especifica una interfaz para registrar callbacks con un tipo de token de parada dado
( concepto solo para exposición* )

Acceso al tamaño de caché (desde C++17)

Definido en el encabezado <new>
(C++17)
desplazamiento mínimo para evitar falso sharing
desplazamiento máximo para promover true sharing
(constante)

Operaciones atómicas

Estos componentes se proporcionan para operaciones atómicas de grano fino que permiten programación concurrente sin bloqueos. Cada operación atómica es indivisible con respecto a cualquier otra operación atómica que involucre el mismo objeto. Los objetos atómicos están libres de carreras de datos .

Definido en el encabezado <atomic>
Tipos atómicos
(C++11)
plantilla de clase atomic y especializaciones para bool, integral, floating-point, (since C++20) y tipos de puntero
(plantilla de clase)
(C++20)
proporciona operaciones atómicas en objetos no atómicos
(plantilla de clase)
Operaciones sobre tipos atómicos
(C++11)
verifica si las operaciones del tipo atómico son libres de bloqueo
(plantilla de función)
(C++11) (C++11)
reemplaza atómicamente el valor del objeto atómico con un argumento no atómico
(plantilla de función)
(C++11) (C++11)
obtiene atómicamente el valor almacenado en un objeto atómico
(plantilla de función)
(C++11) (C++11)
reemplaza atómicamente el valor del objeto atómico con el argumento no atómico y devuelve el valor anterior del atómico
(plantilla de función)
(C++11) (C++11) (C++11) (C++11)
compara atómicamente el valor del objeto atómico con el argumento no atómico y realiza un intercambio atómico si son iguales o una carga atómica si no lo son
(plantilla de función)
(C++11) (C++11)
agrega un valor no atómico a un objeto atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++11) (C++11)
resta un valor no atómico de un objeto atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++11) (C++11)
reemplaza el objeto atómico con el resultado de la operación AND a nivel de bits con un argumento no atómico y obtiene el valor previo del objeto atómico
(plantilla de función)
(C++11) (C++11)
reemplaza el objeto atómico con el resultado de OR a nivel de bits con un argumento no atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++11) (C++11)
reemplaza el objeto atómico con el resultado de la operación XOR bit a bit con un argumento no atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++26) (C++26)
reemplaza el objeto atómico con el resultado de std::max con un argumento no atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++26) (C++26)
reemplaza el objeto atómico con el resultado de std::min con un argumento no atómico y obtiene el valor previo del atómico
(plantilla de función)
(C++20) (C++20)
bloquea el hilo hasta que sea notificado y el valor atómico cambie
(plantilla de función)
(C++20)
notifica a un hilo bloqueado en atomic_wait
(plantilla de función)
(C++20)
notifica a todos los hilos bloqueados en atomic_wait
(plantilla de función)
Tipo de bandera y operaciones
(C++11)
el tipo atómico booleano libre de bloqueo
(clase)
(C++11) (C++11)
establece atómicamente la bandera a true y devuelve su valor anterior
(función)
(C++11) (C++11)
establece atómicamente el valor del flag a false
(función)
(C++20) (C++20)
devuelve atómicamente el valor del indicador
(función)
(C++20) (C++20)
bloquea el hilo hasta que sea notificado y la bandera cambie
(función)
(C++20)
notifica a un hilo bloqueado en atomic_flag_wait
(función)
(C++20)
notifica todos los hilos bloqueados en atomic_flag_wait
(función)
Inicialización
(C++11) (obsoleto en C++20)
inicialización no atómica de un objeto atómico construido por defecto
(plantilla de función)
(C++11) (obsoleto en C++20)
inicialización constante de una variable atómica de duración de almacenamiento estático
(macro de función)
(C++11)
inicializa un std::atomic_flag a false
(constante macro)
Ordenamiento de sincronización de memoria
(C++11)
define las restricciones de ordenamiento de memoria para la operación atómica dada
(enum)
(C++11) (obsoleto en C++26)
elimina el objeto especificado del std::memory_order_consume árbol de dependencias
(plantilla de función)
(C++11)
primitiva de sincronización de barrera genérica dependiente del orden de memoria
(función)
(C++11)
barrera entre un hilo y un manejador de señales ejecutado en el mismo hilo
(función)
Definido en el encabezado <stdatomic.h>
Macros de compatibilidad con C (since C++23)
(C++23)
macro de compatibilidad tal que _Atomic ( T ) es idéntico a std:: atomic < T >
(macro de función)

Ni la macro _Atomic , ni ninguna de las declaraciones del espacio de nombres global no macro son proporcionadas por ningún encabezado de la biblioteca estándar de C++ aparte de <stdatomic.h> .

Exclusión mutua

Los algoritmos de exclusión mutua evitan que múltiples hilos accedan simultáneamente a recursos compartidos. Esto previene condiciones de carrera y proporciona soporte para sincronización entre hilos.

Definido en el encabezado <mutex>
(C++11)
proporciona funcionalidad básica de exclusión mutua
(clase)
(C++11)
proporciona funcionalidad de exclusión mutua que implementa bloqueo con tiempo de espera
(clase)
(C++11)
proporciona funcionalidad de exclusión mutua que puede ser bloqueada recursivamente por el mismo hilo
(clase)
(C++11)
proporciona funcionalidad de exclusión mutua que puede ser bloqueada recursivamente
por el mismo hilo e implementa bloqueo con tiempo de espera
(clase)
Definido en el encabezado <shared_mutex>
(C++17)
proporciona funcionalidad de exclusión mutua compartida
(clase)
(C++14)
proporciona funcionalidad de exclusión mutua compartida e implementa bloqueo con tiempo de espera
(clase)
Gestión genérica de mutex
Definido en el encabezado <mutex>
(C++11)
implementa un contenedor de propiedad de mutex estrictamente basado en ámbito
(plantilla de clase)
(C++17)
contenedor RAII que evita interbloqueos para múltiples mutex
(plantilla de clase)
(C++11)
implementa contenedor de propiedad de mutex movable
(plantilla de clase)
(C++14)
implementa contenedor de propiedad de mutex compartido movable
(plantilla de clase)
(C++11)
etiquetas utilizadas para especificar estrategias de bloqueo
(etiqueta)
Algoritmos genéricos de bloqueo
(C++11)
intenta obtener la propiedad de mutex mediante llamadas repetidas a try_lock
(plantilla de función)
(C++11)
bloquea mutex especificados, se bloquea si alguno no está disponible
(plantilla de función)
Llamada única
(C++11)
objeto auxiliar para garantizar que call_once invoque la función solo una vez
(clase)
(C++11)
invoca una función solo una vez incluso si se llama desde múltiples hilos
(plantilla de función)

Variables de condición

Una variable de condición es una primitiva de sincronización que permite que múltiples hilos se comuniquen entre sí. Permite que cierto número de hilos esperen (posiblemente con un tiempo de espera) la notificación de otro hilo para que puedan proceder. Una variable de condición siempre está asociada con un mutex.

Definido en el encabezado <condition_variable>
(C++11)
proporciona una variable de condición asociada con un std::unique_lock
(clase)
(C++11)
proporciona una variable de condición asociada con cualquier tipo de bloqueo
(clase)
(C++11)
programa una llamada a notify_all para ser invocada cuando este hilo esté completamente terminado
(función)
(C++11)
enumera los posibles resultados de esperas temporizadas en variables de condición
(enumeración)

Semáforos (desde C++20)

Un semáforo es una primitiva de sincronización ligera utilizada para restringir el acceso concurrente a un recurso compartido. Cuando cualquiera de los dos es suficiente, un semáforo puede ser más eficiente que una variable de condición.

Definido en el encabezado <semaphore>
(C++20)
semáforo que modela un contador de recursos no negativo
(plantilla de clase)
(C++20)
semáforo que tiene solo dos estados
(typedef)

Cierres y Barreras (desde C++20)

Los latches y las barreras son mecanismos de coordinación de hilos que permiten que cualquier número de hilos se bloqueen hasta que llegue un número esperado de hilos. Un latch no se puede reutilizar, mientras que una barrera se puede usar repetidamente.

Definido en el encabezado <latch>
(C++20)
barrera de hilos de un solo uso
(clase)
Definido en el encabezado <barrier>
(C++20)
barrera de hilos reutilizable
(plantilla de clase)

Futuros

La biblioteca estándar proporciona facilidades para obtener valores que son devueltos y para capturar excepciones que son lanzadas por tareas asíncronas (es decir, funciones iniciadas en hilos separados). Estos valores se comunican en un estado compartido , en el cual la tarea asíncrona puede escribir su valor de retorno o almacenar una excepción, y que puede ser examinado, esperado y manipulado de otra manera por otros hilos que mantienen instancias de std::future o std::shared_future que referencian ese estado compartido.

Definido en el encabezado <future>
(C++11)
almacena un valor para recuperación asíncrona
(plantilla de clase)
(C++11)
empaqueta una función para almacenar su valor de retorno para recuperación asíncrona
(plantilla de clase)
(C++11)
espera un valor que se establece asíncronamente
(plantilla de clase)
(C++11)
espera un valor (posiblemente referenciado por otros futures) que se establece asíncronamente
(plantilla de clase)
(C++11)
ejecuta una función asíncronamente (potencialmente en un nuevo hilo) y retorna un std::future que contendrá el resultado
(plantilla de función)
(C++11)
especifica la política de lanzamiento para std::async
(enum)
(C++11)
especifica los resultados de esperas temporizadas realizadas en std::future y std::shared_future
(enum)
Errores de future
(C++11)
reporta un error relacionado con futures o promises
(clase)
(C++11)
identifica la categoría de error de future
(función)
(C++11)
identifica los códigos de error de future
(enum)

Reclamación segura (since C++26)

Las técnicas de safe-reclamation se utilizan con mayor frecuencia para resolver directamente las carreras de acceso-eliminación.

Mecanismo Read-Copy-Update
Definido en el encabezado <rcu>
(C++26)
permite que un objeto sea protegido por RCU
(plantilla de clase)
(C++26)
proporciona regiones de protección RCU
(clase)
(C++26)
devuelve una referencia a un objeto de duración estática de tipo std::rcu_domain
(función)
(C++26)
bloquea hasta que una región de protección se desbloquea en un dominio RCU
(función)
(C++26)
puede evaluar operaciones programadas en un dominio RCU y bloquea hasta que todas las evaluaciones precedentes se completen
(función)
(C++26)
programa la evaluación de una función especificada en un dominio RCU, potencialmente asignando memoria e invocando evaluaciones programadas
(plantilla de función)
Punteros de riesgo
Definido en el encabezado <hazard_pointer>
(C++26)
permite que un objeto sea protegible contra riesgos
(plantilla de clase)
(C++26)
puntero de escritor único y múltiples lectores que puede ser propiedad de como máximo un hilo en cualquier momento
(clase)
(C++26)
construye un puntero de riesgo
(función)

Véase también

Documentación de C para Biblioteca de soporte para concurrencia