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++ inclut une prise en charge intégrée des threads, des opérations atomiques, des exclusions mutuelles, des variables condition et des futures.

Table des matières

Fils d'exécution

Les threads permettent aux programmes de s'exécuter sur plusieurs cœurs de processeur.

Défini dans l'en-tête <thread>
(C++11)
gère un thread séparé
(classe)
(C++20)
std::thread avec support pour l'auto-join et l'annulation
(classe)
Fonctions gérant le thread courant
Défini dans l'espace de noms this_thread
(C++11)
suggère à l'implémentation de replanifier l'exécution des threads
(fonction)
(C++11)
retourne l'identifiant du thread courant
(fonction)
(C++11)
arrête l'exécution du thread courant pour une durée spécifiée
(fonction)
(C++11)
arrête l'exécution du thread courant jusqu'à un point temporel spécifié
(fonction)

Annulation coopérative (depuis C++20)

Les composants stop source , stop token , et stop callback peuvent être utilisés pour demander de manière asynchrone qu'une opération cesse son exécution en temps opportun, généralement parce que le résultat n'est plus requis. Une telle demande est appelée une stop request .

Ces composants spécifient la sémantique d'accès partagé à un état d'arrêt . Tout objet modélisant l'un de ces composants qui se réfère au même état d'arrêt est respectivement une source d'arrêt, un jeton d'arrêt ou un rappel d'arrêt associé.

Les concepts stoppable-source , stoppable_token , et stoppable-callback-for spécifient respectivement la syntaxe requise et la sémantique de modèle de la source d'arrêt, du jeton d'arrêt et du rappel d'arrêt.

(depuis C++26)

Ils sont conçus :

  • pour effectuer l'achèvement arrêté d'une opération asynchrone créée par execution::connect ,
(depuis C++26)
  • ou pour une implémentation personnalisée de gestion d'exécution.

En fait, ils n'ont même pas besoin d'être utilisés pour "arrêter" quoi que ce soit, mais peuvent plutôt servir de déclencheur d'invocation unique et sécurisé pour les threads, par exemple.

Défini dans l'en-tête <stop_token>
Types de stop token
(C++20)
une interface pour interroger si une demande d'annulation std::jthread a été effectuée
(classe)
(C++26)
fournit une interface de stop token pour laquelle un arrêt n'est jamais possible ni demandé
(classe)
(C++26)
un stop token qui référence l'état d'arrêt de son objet std::inplace_stop_source associé
(classe)
Types de stop source
(C++20)
classe représentant une demande d'arrêt d'une ou plusieurs std::jthread s
(classe)
(C++26)
une stoppable-source qui est le seul propriétaire de l'état d'arrêt
(classe)
Types de stop callback
(C++20)
une interface pour enregistrer des callbacks sur l'annulation std::jthread
(modèle de classe)
(C++26)
un stop callback pour std::inplace_stop_token
(modèle de classe)
(C++26)
obtient le type de callback pour un type de stop token donné
(modèle d'alias)
Concepts (depuis C++20)
(C++26)
spécifie l'interface de base des stop tokens qui permet d'interroger les demandes d'arrêt et si la demande d'arrêt est possible
(concept)
(C++26)
spécifie un stop token qui ne permet pas l'arrêt
(concept)
(C++26)
spécifie qu'un type est une fabrique pour les stop tokens associés et qu'une demande d'arrêt peut être effectuée sur celui-ci
( concept* à titre d'exposition uniquement )
(C++26)
spécifie une interface pour enregistrer des callbacks avec un type de stop token donné
( concept* à titre d'exposition uniquement )

Accès à la taille du cache (depuis C++17)

Défini dans l'en-tête <new>
(C++17)
décalage minimal pour éviter le faux partage
décalage maximal pour favoriser le vrai partage
(constante)

Opérations atomiques

Ces composants sont fournis pour des opérations atomiques fines permettant une programmation concurrente sans verrou. Chaque opération atomique est indivisible par rapport à toute autre opération atomique impliquant le même objet. Les objets atomiques sont exempts de courses de données .

Défini dans l'en-tête <atomic>
Types atomiques
(C++11)
Modèle de classe atomic et spécialisations pour les types booléens, entiers, virgule flottante, (depuis C++20) et pointeurs
(modèle de classe)
(C++20)
fournit des opérations atomiques sur des objets non atomiques
(modèle de classe)
Opérations sur les types atomiques
(C++11)
vérifie si les opérations du type atomique sont sans verrouillage
(fonction template)
(C++11) (C++11)
remplace atomiquement la valeur de l'objet atomique avec un argument non-atomique
(modèle de fonction)
(C++11) (C++11)
obtient atomiquement la valeur stockée dans un objet atomique
(modèle de fonction)
(C++11) (C++11)
remplace atomiquement la valeur de l'objet atomique par l'argument non atomique et retourne l'ancienne valeur de l'atome
(modèle de fonction)
(C++11) (C++11) (C++11) (C++11)
compare atomiquement la valeur de l'objet atomique avec l'argument non atomique et effectue un échange atomique si égal ou un chargement atomique sinon
(modèle de fonction)
(C++11) (C++11)
ajoute une valeur non atomique à un objet atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++11) (C++11)
soustrait une valeur non atomique d'un objet atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++11) (C++11)
remplace l'objet atomique par le résultat de l'opération ET bit à bit avec un argument non atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++11) (C++11)
remplace l'objet atomique par le résultat du OU binaire avec un argument non atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++11) (C++11)
remplace l'objet atomique par le résultat du XOR bit à bit avec un argument non atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++26) (C++26)
remplace l'objet atomique par le résultat de std::max avec un argument non atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++26) (C++26)
remplace l'objet atomique par le résultat de std::min avec un argument non atomique et obtient la valeur précédente de l'atome
(modèle de fonction)
(C++20) (C++20)
bloque le thread jusqu'à notification et changement de la valeur atomique
(modèle de fonction)
(C++20)
notifie un thread bloqué dans atomic_wait
(fonction template)
(C++20)
notifie tous les threads bloqués dans atomic_wait
(modèle de fonction)
Type de drapeau et opérations
(C++11)
le type atomique booléen sans verrouillage
(classe)
(C++11) (C++11)
définit atomiquement le drapeau à true et retourne sa valeur précédente
(fonction)
(C++11) (C++11)
définit atomiquement la valeur du drapeau à false
(fonction)
(C++20) (C++20)
retourne atomiquement la valeur du drapeau
(fonction)
(C++20) (C++20)
bloque le thread jusqu'à notification et changement du drapeau
(fonction)
(C++20)
notifie un thread bloqué dans atomic_flag_wait
(fonction)
(C++20)
notifie tous les threads bloqués dans atomic_flag_wait
(fonction)
Initialisation
(C++11) (obsolète en C++20)
initialisation non atomique d'un objet atomic construit par défaut
(modèle de fonction)
(C++11) (obsolète en C++20)
initialisation constante d'une variable atomique de durée de stockage statique
(macro de fonction)
(C++11)
initialise un std::atomic_flag à false
(constante macro)
Ordre de synchronisation de la mémoire
(C++11)
définit les contraintes d'ordonnancement de la mémoire pour l'opération atomique donnée
(enum)
(C++11) (obsolète en C++26)
supprime l'objet spécifié de l'arbre de dépendances std::memory_order_consume
(modèle de fonction)
(C++11)
primitive de synchronisation de barrière générique dépendant de l'ordre mémoire
(fonction)
(C++11)
barrière entre un thread et un gestionnaire de signal exécuté dans le même thread
(fonction)
Défini dans l'en-tête <stdatomic.h>
Macros de compatibilité C (depuis C++23)
(C++23)
macro de compatibilité tel que _Atomic ( T ) est identique à std:: atomic < T >
(macro fonction)

Ni la macro _Atomic , ni aucune des déclarations de l'espace de noms global non-macro n'est fournie par un en-tête de bibliothèque standard C++ autre que <stdatomic.h> .

Exclusion mutuelle

Les algorithmes d'exclusion mutuelle empêchent plusieurs threads d'accéder simultanément aux ressources partagées. Cela prévient les courses aux données et fournit un support pour la synchronisation entre threads.

Défini dans l'en-tête <mutex>
(C++11)
fournit une fonctionnalité d'exclusion mutuelle de base
(classe)
(C++11)
fournit une fonctionnalité d'exclusion mutuelle implémentant le verrouillage avec délai d'attente
(classe)
(C++11)
fournit une fonctionnalité d'exclusion mutuelle pouvant être verrouillée récursivement par le même thread
(classe)
(C++11)
fournit une fonctionnalité d'exclusion mutuelle pouvant être verrouillée récursivement
par le même thread et implémentant le verrouillage avec délai d'attente
(classe)
Défini dans l'en-tête <shared_mutex>
(C++17)
fournit une fonctionnalité d'exclusion mutuelle partagée
(classe)
(C++14)
fournit une fonctionnalité d'exclusion mutuelle partagée et implémente le verrouillage avec délai d'attente
(classe)
Gestion générique des mutex
Défini dans l'en-tête <mutex>
(C++11)
implémente un wrapper de propriété de mutex strictement basé sur la portée
(modèle de classe)
(C++17)
wrapper RAII évitant les interblocages pour plusieurs mutex
(modèle de classe)
(C++11)
implémente un wrapper de propriété de mutex déplaçable
(modèle de classe)
(C++14)
implémente un wrapper de propriété de mutex partagé déplaçable
(modèle de classe)
(C++11)
balises utilisées pour spécifier la stratégie de verrouillage
(balise)
Algorithmes génériques de verrouillage
(C++11)
tente d'obtenir la propriété des mutex via des appels répétés à try_lock
(modèle de fonction)
(C++11)
verrouille les mutex spécifiés, bloque si l'un d'eux n'est pas disponible
(modèle de fonction)
Appel unique
(C++11)
objet assistant pour garantir que call_once n'invoque la fonction qu'une seule fois
(classe)
(C++11)
n'invoque une fonction qu'une seule fois même si appelée depuis plusieurs threads
(modèle de fonction)

Variables de condition

Une variable de condition est un primitif de synchronisation qui permet à plusieurs threads de communiquer entre eux. Elle permet à un certain nombre de threads d'attendre (éventuellement avec un délai d'expiration) une notification d'un autre thread indiquant qu'ils peuvent poursuivre. Une variable de condition est toujours associée à un mutex.

Défini dans l'en-tête <condition_variable>
(C++11)
fournit une variable de condition associée à un std::unique_lock
(classe)
(C++11)
fournit une variable de condition associée à tout type de verrou
(classe)
(C++11)
planifie un appel à notify_all à invoquer lorsque ce thread est complètement terminé
(fonction)
(C++11)
énumère les résultats possibles des attentes temporisées sur les variables de condition
(énumération)

Sémaphores (depuis C++20)

Un sémaphore est une primitive de synchronisation légère utilisée pour restreindre l'accès concurrent à une ressource partagée. Lorsque l'un ou l'autre suffit, un sémaphore peut être plus efficace qu'une variable de condition.

Défini dans l'en-tête <semaphore>
(C++20)
sémaphore modélisant un compteur de ressources non négatif
(modèle de classe)
(C++20)
sémaphore n'ayant que deux états
(typedef)

Verrous et Barrières (depuis C++20)

Les verrous et les barrières sont des mécanismes de coordination de threads qui permettent à un nombre quelconque de threads de se bloquer jusqu'à ce qu'un nombre attendu de threads arrive. Un verrou ne peut pas être réutilisé, tandis qu'une barrière peut être utilisée de manière répétée.

Défini dans l'en-tête <latch>
(C++20)
barrière de thread à usage unique
(classe)
Défini dans l'en-tête <barrier>
(C++20)
barrière de thread réutilisable
(modèle de classe)

Futures

La bibliothèque standard fournit des fonctionnalités pour obtenir les valeurs retournées et pour intercepter les exceptions levées par des tâches asynchrones (c'est-à-dire des fonctions lancées dans des threads séparés). Ces valeurs sont communiquées dans un état partagé , dans lequel la tâche asynchrone peut écrire sa valeur de retour ou stocker une exception, et qui peut être examiné, attendu, et autrement manipulé par d'autres threads qui détiennent des instances de std::future ou std::shared_future qui référencent cet état partagé.

Défini dans l'en-tête <future>
(C++11)
stocke une valeur pour une récupération asynchrone
(modèle de classe)
(C++11)
empaquette une fonction pour stocker sa valeur de retour pour une récupération asynchrone
(modèle de classe)
(C++11)
attend une valeur définie de manière asynchrone
(modèle de classe)
(C++11)
attend une valeur (potentiellement référencée par d'autres futures) définie de manière asynchrone
(modèle de classe)
(C++11)
exécute une fonction de manière asynchrone (potentiellement dans un nouveau thread) et retourne un std::future qui contiendra le résultat
(modèle de fonction)
(C++11)
spécifie la politique de lancement pour std::async
(énumération)
(C++11)
spécifie les résultats des attentes temporisées effectuées sur std::future et std::shared_future
(énumération)
Erreurs de future
(C++11)
signale une erreur liée aux futures ou aux promises
(classe)
(C++11)
identifie la catégorie d'erreur de future
(fonction)
(C++11)
identifie les codes d'erreur de future
(énumération)

Réclamation sécurisée (since C++26)

Les techniques de réclamation sécurisée sont le plus souvent utilisées pour résoudre directement les courses d'accès-suppression.

Mécanisme Read-Copy-Update
Défini dans l'en-tête <rcu>
(C++26)
permet à un objet d'être protégé par RCU
(modèle de classe)
(C++26)
fournit des régions de protection RCU
(classe)
(C++26)
retourne une référence à un objet de durée statique de type std::rcu_domain
(fonction)
(C++26)
bloque jusqu'à ce qu'une région de protection se déverrouille sur un domaine RCU
(fonction)
(C++26)
peut évaluer les opérations planifiées sur un domaine RCU et bloque jusqu'à ce que toutes les évaluations précédentes soient terminées
(fonction)
(C++26)
planifie l'évaluation d'une fonction spécifiée sur un domaine RCU, allouant potentiellement de la mémoire et invoquant les évaluations planifiées
(modèle de fonction)
Pointeurs de risque
Défini dans l'en-tête <hazard_pointer>
(C++26)
permet à un objet d'être protégé par pointeur de risque
(modèle de classe)
(C++26)
pointeur multi-lecteur mono-écrivain qui peut être détenu par au plus un thread à tout moment
(classe)
(C++26)
construit un pointeur de risque
(fonction)

Voir aussi

Documentation C pour Bibliothèque de support de la concurrence