Biblioteca de apoyo de concurrencia (desde C++11)
C++ incluye apoyo integrado para hilos, operaciones atómicas, exclusión mutua, variables de condición y futuros.
Contenido |
[editar]Hilos
Los hilos permiten a los programas ejecutar a lo largo de varios núcleos de procesador.
Definido en el archivo de encabezado <thread> | |
(C++11) | Gestiona un hilo/subproceso independiente. (clase) |
(C++20) | std::thread con soporte para unión y cancelación automática. (clase) |
Funciones que gestionan el hilo actual | |
Definido en el espacio de nombres this_thread | |
(C++11) | Sugiere a la implementación que reprograme la ejecución de hilos. (función) |
(C++11) | Devuelve el identificador de hilo/subproceso del hilo/subproceso actual. (función) |
(C++11) | Detiene la ejecución del hilo/subproceso actual por una duración de tiempo especificada. (función) |
(C++11) | Detiene la ejecución del hilo/subproceso actual hasta que ocurra un punto de tiempo especificado. (función) |
Cancelación cooperativaLos componentes fuente de detención (stop source), token de detención (stop token) y devolución de llamada de detención (stop callback) se pueden utilizar para solicitar de forma asincrónica que una operación detenga su ejecución de manera oportuna, generalmente porque el resultado ya no es necesario. Este tipo de solicitud se denomina solicitud de detención (stop request). Estos componentes especifican la semántica del acceso compartido a un estado de detención (stop state) . Cualquier objeto que modele cualquiera de estos componentes que hagan referencia al mismo estado de detención es una fuente de detención, un token de detención o una devolución de llamada de detención asociados, respectivamente.
Están diseñados:
De hecho, ni siquiera necesitan usarse para “detener” nada, sino que pueden usarse, por ejemplo, para un disparador de invocación de funciones de un solo uso seguro para hilos.
| (desde C++20) | ||||||||||||||||||||||||||||||||||||||
[editar]Acceso al tamaño de la caché
Definido en el archivo de encabezado <new> | |
| Desplazamiento mínimo para evitar compartimiento falso (false sharing). Desplazamiento máximo para promover compartimiento verdadero (true sharing). (constante) | |
[editar]Operaciones atómicas
Estos componentes se proporcionan para operaciones atómicas de grano fino que permiten una programación concurrente sin bloqueos. Cada operación atómica es indivisible con respecto a cualquier otra operación atómica que involucre al mismo objeto. Los objetos atómicos están libres de carreras de datos.
Ni la macro | (desde C++23) |
Definido en el archivo de encabezado <atomic> | |
Tipos atómicos | |
(C++11) | Plantilla de clase atómica y especializaciones para los tipos bool, enteros y tipos puntero. (plantilla de clase) |
(C++20) | Proporciona operaciones atómicas en objetos no atómicos. (plantilla de clase) |
Operaciones en tipos atómicos | |
(C++11) | Comprueba si las operaciones del tipo atómico son sin bloqueo. (plantilla de función) |
(C++11)(C++11) | Sustituye atómicamente el valor del objeto atómico con el de 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 del argumento no atómico y devuelve el valor anterior del objeto atómico. (plantilla de función) |
| 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 anterior del objeto 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 anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) | Reemplaza el objeto atómico con el resultado de la operación lógica AND con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) | Reemplaza el objeto atómico con el resultado de la operación lógica OR con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) | Reemplaza el objeto atómico con el resultado de la operación lógica XOR con un argumento no atómico y obtiene el valor anterior del objeto 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 anterior 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 anterior del atómico. (plantilla de función) |
(C++20)(C++20) | Bloquea el hilo/subproceso hasta que se reciba una notificación 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 indicador y operaciones | |
(C++11) | El tipo atómico booleano libre de bloqueo. (clase) |
| Establece atómicamente la bandera a true y devuelve su valor anterior. (función) | |
(C++11)(C++11) | Establece atómicamente el valor de la bandera a false. (función) |
(C++20)(C++20) | Devuelve atómicamente el valor de la bandera. (función) |
(C++20)(C++20) | Bloquea el hilo/subproceso hasta que haya una notificación y la bandera cambie. (función) |
(C++20) | Notifica a un hilo bloqueado en atomic_flag_wait. (función) |
(C++20) | Notifica a todos los hilos bloqueados en atomic_flag_wait. (función) |
Inicialización | |
(C++11)(en desuso en C++20) | Inicialización no atómica de un objeto atómico construido por defecto. (plantilla de función) |
(C++11) | Inicialización por constante de una variable atómica de duración de almacenamiento estática. (macro de función) |
(C++11) | Inicializa una bandera std::atomic_flag a false. (constante de macro) |
Orden de sincronización de memoria | |
(C++11) | Define las restricciones del ordenamiento de memoria para la operación atómica dada. (typedef) |
(C++11) | Quita el objeto especificado del árbol de dependencias de std::memory_order_consume. (plantilla de función) |
(C++11) | Primitiva de sincronización de barrera genérica de memoria dependiente del orden. (función) |
(C++11) | Barrera entre un hilo y un controlador de señales ejecutados en el mismo hilo/subproceso. (función) |
Definido en el archivo de encabezado <stdatomic.h> | |
Macros de compatibilidad con C | |
(C++23) | Macro de compatibilidad tal que _Atomic(T) es idéntico a std::atomic<T> (macro de función) |
[editar]Exclusión mutua
Los algoritmos de exclusión mutua previenen que el acceso simultáneo de varios hilos a recursos compartidos. Esto previene carreras de datos y proporciona apoyo para la sincronización entre hilos.
Definido en el archivo de encabezado <mutex> | |
(C++11) | Proporciona servicios de exclusión mutua básicos. (clase) |
(C++11) | Proporciona un servicio de exclusión mutua que implementa bloqueo con un tiempo de espera. (clase) |
(C++11) | Proporciona un servicio de bloqueo mutuo que puede ser bloqueado recursivamente por el mismo hilo/subproceso. (clase) |
(C++11) | Proporciona un servicio de exclusión mutua que puede ser bloqueado recursivamente por el mismo hilo e implementa bloqueo con un tiempo de espera. (clase) |
Definido en el archivo de encabezado <shared_mutex> | |
(C++17) | Proporciona un servicio de exclusión mutua compartida. (clase) |
(C++14) | Proporciona un servicio de exclusión mutua compartida e implementa bloqueo con un tiempo de espera. (clase) |
Gestión genérica de mutex | |
Definido en el archivo de encabezado <mutex> | |
(C++11) | Implementa un envoltorio de propiedad de mutex estrictamente basado en un ámbito. (plantilla de clase) |
(C++17) | Envoltorio RAII que evita bloqueo mutuo para múltiples mutex. (plantilla de clase) |
(C++11) | Implementa un envoltorio de propiedad de mutex movible. (plantilla de clase) |
(C++14) | Implementa un envoltorio de propiedad de un mutex movible. (plantilla de clase) |
(C++11)(C++11)(C++11) | Constantes de etiqueta que se utilizan para la estrategia de bloqueo. (constante) |
Algoritmos de bloqueo genéricos | |
(C++11) | Intenta tomar posesión de los mutex mediante llamadas repetidas a try_lock. (plantilla de función) |
(C++11) | Bloquea los mutex especificados. Se bloquea si ninguno está disponible. (plantilla de función) |
Llamar una vez | |
(C++11) | Objeto auxiliar para asegurarse que call_once invoque la función una sola vez. (clase) |
(C++11) | Invoca una función una sola vez inclusive si se llama desde varios hilos. (plantilla de función) |
[editar]Variables de condición
Una variable de condición es una primitiva de sincronización que facilita que múltiples hilos puedan comunicarse entre sí. Permite que algunos hilos esperen (posiblemente con un tiempo máximo de espera) hasta que llegue la notificación de otro hilo para que puedan continuar. Una variable de condición siempre está asociada a un mutex.
Definido en el archivo de encabezado <condition_variable> | |
(C++11) | Proporciona una variable de condición asociada con un cerrojo único, std::unique_lock (clase) |
(C++11) | Proporciona una variable de condición asociada con cualquier tipo de cerrojo (clase) |
(C++11) | Programa una llamada a notify_all para que se invoque cuando este hilo haya finalizado por completo (función) |
(C++11) | Lista los posibles resultados de las esperas cronometradas en las variables de condición (enum) |
SemáforosUn semáforo (semaphore) es una primitiva de sincronización de peso ligero utilizado para restringir el acceso concurrente a un recurso compartido. Cuando es posible usar ambos, un semáforo es más eficiente que una variable de condición.
Pestillos y barrerasLos pestillos (latches) y las barreras (barriers) son mecanismos de coordinación de hilos que permiten que cualquier número de hilos se bloqueen hasta que un número esperado de hilos llegue a la barrera. Los pestillos no pueden reutilizarse, mientras que las barreras pueden utilizarse repetidamente.
| (desde C++20) | ||||||||||||||
[editar]Futuros
La biblioteca estándar proporciona servicios para la obtención de los valores que se devuelven y para atrapar las excepciones lanzadas por tareas asincrónas (es decir, las funciones puestas en marcha por hilos). Estos valores se comunican mediante un estado compartido, en el que las tareas asíncronas pueden escribir su valor de retorno o almacenar una excepción, la cual puede examinarse, esperar por ella, y de otra forma manipulada por otros hilos que mantienen ejemplares de std::future o std::shared_future que referencian ese estado compartido.
Definido en el archivo de 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 la recuperación asíncrona. (plantilla de clase) |
(C++11) | Espera a un valor que se establece asíncronamente. (plantilla de clase) |
(C++11) | Espera a un valor (posiblemente referenciado por otros futuros) que se ha establecido asíncronamente. (plantilla de clase) |
(C++11) | Ejecuta una función asíncronamente (posiblemente en un nuevo hilo) y devuelve un std::future que contendrá el resultado. (plantilla de función) |
(C++11) | Especifica la política de lanzamiento de std::async. (enum) |
(C++11) | Especifica los resultados de esperas cronometradas realizadas en std::future y std::shared_future. (enum) |
Errores de futuros | |
(C++11) | Informa de un error relacionado con futuros o promesas. (clase) |
(C++11) | Identifica la categoría de error del futuro. (función) |
(C++11) | Identifica los códigos de error del futuro. (enum) |
Recuperación seguraLas técnicas de recuperación segura se utilizan con mayor frecuencia para resolver de manera directa las carreras de acceso y eliminación.
| (desde C++26) | ||||||||||||||||||||||||||
[editar]Véase también
Documentación de C para Biblioteca de apoyo de concurrencia |
