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++ bietet eingebaute Unterstützung für Threads, atomare Operationen, gegenseitigen Ausschluss, Bedingungsvariablen und Futures.

Inhaltsverzeichnis

Threads

Threads ermöglichen Programmen die Ausführung über mehrere Prozessorkerne.

Definiert im Header <thread>
(C++11)
verwaltet einen separaten Thread
(Klasse)
(C++20)
std::thread mit Unterstützung für automatisches Join und Abbruch
(Klasse)
Funktionen zur Verwaltung des aktuellen Threads
Definiert im Namespace this_thread
(C++11)
schlägt vor, dass die Implementierung die Ausführung von Threads neu plant
(Funktion)
(C++11)
gibt die Thread-ID des aktuellen Threads zurück
(Funktion)
(C++11)
hält die Ausführung des aktuellen Threads für eine bestimmte Zeitdauer an
(Funktion)
(C++11)
hält die Ausführung des aktuellen Threads bis zu einem bestimmten Zeitpunkt an
(Funktion)

Kooperative Abbruchbehandlung (seit C++20)

Die Komponenten stop source , stop token und stop callback können verwendet werden, um asynchron anzufordern, dass eine Operation ihre Ausführung zeitnah beendet, typischerweise weil das Ergebnis nicht mehr benötigt wird. Eine solche Anforderung wird als stop request bezeichnet.

Diese Komponenten legen die Semantik des gemeinsamen Zugriffs auf einen stop state fest. Jedes Objekt, das eine dieser Komponenten modelliert und sich auf denselben stop state bezieht, ist eine zugehörige stop source, stop token oder stop callback.

Die Konzepte stoppable-source , stoppable_token und stoppable-callback-for spezifizieren die erforderliche Syntax und modellieren die Semantik von Stop-Quelle, Stop-Token bzw. Stop-Callback.

(seit C++26)

Sie sind konzipiert:

  • um einen angehaltenen Abschluss einer asynchronen Operation durchzuführen, die durch execution::connect erstellt wurde,
(seit C++26)
  • oder für eine benutzerdefinierte Implementierung des Ausführungsmanagements.

Tatsächlich müssen sie nicht einmal verwendet werden, um etwas zu "stoppen", sondern können stattdessen beispielsweise als auslösender Mechanismus für einen threadsicheren einmaligen Funktionsaufruf dienen.

Definiert in Header <stop_token>
Stop-Token-Typen
(C++20)
eine Schnittstelle zum Abfragen, ob eine std::jthread Abbruchanforderung gestellt wurde
(Klasse)
(C++26)
bietet eine Stop-Token-Schnittstelle, bei der ein Stopp niemals möglich noch angefordert wird
(Klasse)
(C++26)
ein Stop-Token, das auf den Stop-Zustand seines zugehörigen std::inplace_stop_source Objekts verweist
(Klasse)
Stop-Source-Typen
(C++20)
Klasse, die eine Anforderung zum Stoppen eines oder mehrerer std::jthread s repräsentiert
(Klasse)
(C++26)
eine stoppable-source , die alleiniger Besitzer des Stop-Zustands ist
(Klasse)
Stop-Callback-Typen
(C++20)
eine Schnittstelle zum Registrieren von Callbacks bei std::jthread Abbruch
(Klassentemplate)
(C++26)
ein Stop-Callback für std::inplace_stop_token
(Klassentemplate)
(C++26)
ermittelt den Callback-Typ für einen gegebenen Stop-Token-Typ
(Alias-Template)
Konzepte (seit C++20)
(C++26)
spezifiziert die grundlegende Schnittstelle von Stop-Tokens, die Abfragen nach Stopp-Anforderungen und ob die Stopp-Anforderung möglich ist, erlaubt
(Konzept)
(C++26)
spezifiziert einen Stop-Token, der kein Stoppen erlaubt
(Konzept)
(C++26)
spezifiziert, dass ein Typ eine Fabrik für assoziierte Stop-Tokens ist und eine Stopp-Anforderung darauf gestellt werden kann
( Nur-zur-Veranschaulichung-Konzept* )
(C++26)
spezifiziert eine Schnittstelle zum Registrieren von Callbacks mit einem gegebenen Stop-Token-Typ
( Nur-zur-Veranschaulichung-Konzept* )

Cache-Größen-Zugriff (seit C++17)

Definiert im Header <new>
(C++17)
Minimale Verschiebung zur Vermeidung von False Sharing
Maximale Verschiebung zur Förderung von True Sharing
(Konstante)

Atomare Operationen

Diese Komponenten werden für feingranulare atomare Operationen bereitgestellt, die locklose nebenläufige Programmierung ermöglichen. Jede atomare Operation ist unteilbar in Bezug auf jede andere atomare Operation, die dasselbe Objekt betrifft. Atomare Objekte sind frei von Datenrennen .

Definiert in Header <atomic>
Atomare Typen
(C++11)
atomic-Klassen-Template und Spezialisierungen für bool, Ganzzahltypen, Gleitkommatypen, (seit C++20) und Zeigertypen
(Klassen-Template)
(C++20)
bietet atomare Operationen für nicht-atomare Objekte
(Klassentemplate)
Operationen auf atomaren Typen
(C++11)
prüft, ob die Operationen des atomaren Typs sperrfrei sind
(Funktions-Template)
(C++11) (C++11)
ersetzt atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument
(Funktions-Template)
(C++11) (C++11)
holt den Wert eines atomaren Objekts atomar
(Funktions-Template)
(C++11) (C++11)
ersetzt atomar den Wert des atomaren Objekts mit dem nicht-atomaren Argument und gibt den alten Wert des atomaren Objekts zurück
(Funktionstemplate)
(C++11) (C++11) (C++11) (C++11)
vergleicht atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument und führt atomaren Austausch durch, wenn gleich, oder atomares Laden, wenn nicht gleich
(Funktions-Template)
(C++11) (C++11)
addiert einen nicht-atomaren Wert zu einem atomaren Objekt und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
(C++11) (C++11)
subtrahiert einen nicht-atomaren Wert von einem atomaren Objekt und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
(C++11) (C++11)
ersetzt das atomare Objekt mit dem Ergebnis der bitweisen UND-Verknüpfung mit einem nicht-atomaren Argument und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
(C++11) (C++11)
ersetzt das atomare Objekt mit dem Ergebnis der bitweisen ODER-Verknüpfung mit einem nicht-atomaren Argument und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
(C++11) (C++11)
ersetzt das atomare Objekt mit dem Ergebnis der bitweisen XOR-Operation mit einem nicht-atomaren Argument und erhält den vorherigen Wert des atomaren Objekts
(Funktionstemplate)
(C++26) (C++26)
ersetzt das atomare Objekt mit dem Ergebnis von std::max mit einem nicht-atomaren Argument und erhält den vorherigen Wert des atomaren Objekts
(Funktionsschablone)
(C++26) (C++26)
ersetzt das atomare Objekt mit dem Ergebnis von std::min mit einem nicht-atomaren Argument und erhält den vorherigen Wert des atomaren Objekts
(Funktions-Template)
(C++20) (C++20)
blockiert den Thread, bis eine Benachrichtigung erfolgt und der atomare Wert sich ändert
(Funktions-Template)
(C++20)
benachrichtigt einen in atomic_wait blockierten Thread
(Funktions-Template)
(C++20)
benachrichtigt alle in atomic_wait blockierten Threads
(Funktionstemplate)
Flag-Typ und Operationen
(C++11)
der lock-freie boolesche atomare Typ
(Klasse)
(C++11) (C++11)
setzt das Flag atomar auf true und gibt seinen vorherigen Wert zurück
(Funktion)
(C++11) (C++11)
setzt den Wert des Flags atomar auf false
(Funktion)
(C++20) (C++20)
gibt den Wert des Flags atomar zurück
(Funktion)
(C++20) (C++20)
blockiert den Thread, bis eine Benachrichtigung erfolgt und das Flag sich ändert
(Funktion)
(C++20)
benachrichtigt einen in atomic_flag_wait blockierten Thread
(Funktion)
(C++20)
benachrichtigt alle Threads, die in atomic_flag_wait blockiert sind
(Funktion)
Initialisierung
(C++11) (veraltet in C++20)
nicht-atomare Initialisierung eines standardkonstruierten atomaren Objekts
(Funktions-Template)
(C++11) (veraltet in C++20)
Konstanteninitialisierung einer atomaren Variable mit statischer Speicherdauer
(Funktionsmakro)
(C++11)
initialisiert ein std::atomic_flag mit false
(Makrokonstante)
Speicher-Synchronisierungsreihenfolge
(C++11)
definiert Speicherordnungsbeschränkungen für die gegebene atomare Operation
(enum)
(C++11) (veraltet in C++26)
entfernt das spezifizierte Objekt aus dem std::memory_order_consume Abhängigkeitsbaum
(Funktions-Template)
(C++11)
generische speicherreihenfolgenabhängige Fence-Synchronisationsprimitive
(Funktion)
(C++11)
Barriere zwischen einem Thread und einem Signal-Handler, der im selben Thread ausgeführt wird
(Funktion)
Definiert in Header <stdatomic.h>
C-Kompatibilitätsmakros (since C++23)
(C++23)
Kompatibilitätsmakro, sodass _Atomic ( T ) identisch ist zu std:: atomic < T >
(Funktionsmakro)

Weder das _Atomic -Makro noch irgendeine der nicht-makro globalen Namespace-Deklarationen wird von einem C++-Standardbibliotheksheader außer <stdatomic.h> bereitgestellt.

Gegenseitiger Ausschluss

Mutual Exclusion Algorithmen verhindern, dass mehrere Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen. Dies verhindert Data Races und bietet Unterstützung für die Synchronisation zwischen Threads.

Definiert im Header <mutex>
(C++11)
bietet grundlegende gegenseitige Ausschluss-Einrichtung
(Klasse)
(C++11)
bietet gegenseitige Ausschluss-Einrichtung mit Timeout-Sperrmechanismus
(Klasse)
(C++11)
bietet gegenseitige Ausschluss-Einrichtung, die rekursiv durch denselben Thread gesperrt werden kann
(Klasse)
(C++11)
bietet gegenseitige Ausschluss-Einrichtung, die rekursiv
durch denselben Thread gesperrt werden kann und Timeout-Sperrmechanismus implementiert
(Klasse)
Definiert im Header <shared_mutex>
(C++17)
bietet gemeinsame gegenseitige Ausschluss-Einrichtung
(Klasse)
(C++14)
bietet gemeinsame gegenseitige Ausschluss-Einrichtung und implementiert Timeout-Sperrmechanismus
(Klasse)
Generisches Mutex-Management
Definiert im Header <mutex>
(C++11)
implementiert einen streng bereichsbasierten Mutex-Besitz-Wrapper
(Klassentemplate)
(C++17)
Deadlock-vermeidender RAII-Wrapper für mehrere Mutexe
(Klassentemplate)
(C++11)
implementiert beweglichen Mutex-Besitz-Wrapper
(Klassentemplate)
(C++14)
implementiert beweglichen Shared-Mutex-Besitz-Wrapper
(Klassentemplate)
(C++11)
Tags zur Spezifikation von Sperrstrategien
(Tag)
Generische Sperralgorithmen
(C++11)
versucht Besitz von Mutexen durch wiederholte Aufrufe von try_lock zu erlangen
(Funktionstemplate)
(C++11)
sperrt spezifizierte Mutexe, blockiert falls nicht verfügbar
(Funktionstemplate)
Einmalaufruf
(C++11)
Hilfsobjekt zur Sicherstellung, dass call_once die Funktion nur einmal aufruft
(Klasse)
(C++11)
ruft eine Funktion nur einmal auf, selbst wenn von mehreren Threads aufgerufen
(Funktionstemplate)

Bedingungsvariablen

Eine Bedingungsvariable ist ein Synchronisationsprimitive, das mehreren Threads ermöglicht, miteinander zu kommunizieren. Es erlaubt einer bestimmten Anzahl von Threads zu warten (möglicherweise mit Timeout) auf eine Benachrichtigung von einem anderen Thread, dass sie fortfahren können. Eine Bedingungsvariable ist immer mit einem Mutex assoziiert.

Definiert im Header <condition_variable>
(C++11)
stellt eine Bedingungsvariable bereit, die mit einem std::unique_lock assoziiert ist
(Klasse)
(C++11)
stellt eine Bedingungsvariable bereit, die mit jedem Sperrtyp assoziiert werden kann
(Klasse)
(C++11)
plant einen Aufruf von notify_all , der ausgeführt werden soll, wenn dieser Thread vollständig beendet ist
(Funktion)
(C++11)
listet die möglichen Ergebnisse von zeitgesteuerten Wartevorgängen auf Bedingungsvariablen auf
(Enumeration)

Semaphoren (seit C++20)

Ein Semaphor ist ein leichtgewichtiges Synchronisationsprimitiv, das verwendet wird, um den gleichzeitigen Zugriff auf eine gemeinsam genutzte Ressource einzuschränken. Wenn beide ausreichen würden, kann ein Semaphor effizienter sein als eine Bedingungsvariable.

Definiert im Header <semaphore>
(C++20)
Semaphor, das einen nicht-negativen Ressourcenzähler modelliert
(Klassentemplate)
(C++20)
Semaphor, das nur zwei Zustände hat
(Typdefinition)

Latches und Barriers (seit C++20)

Latches und Barriers sind Thread-Koordinationsmechanismen, die es einer beliebigen Anzahl von Threads ermöglichen, zu blockieren, bis eine erwartete Anzahl von Threads eintrifft. Ein Latch kann nicht wiederverwendet werden, während eine Barrier wiederholt verwendet werden kann.

Definiert im Header <latch>
(C++20)
Einmalige Thread-Barriere
(Klasse)
Definiert im Header <barrier>
(C++20)
Wiederverwendbare Thread-Barriere
(Klassen-Template)

Futures

Die Standardbibliothek bietet Einrichtungen, um Werte zu erhalten, die zurückgegeben werden, und Ausnahmen abzufangen, die von asynchronen Aufgaben geworfen werden (d.h. Funktionen, die in separaten Threads gestartet werden). Diese Werte werden in einem shared state kommuniziert, in dem die asynchrone Aufgabe ihren Rückgabewert schreiben oder eine Ausnahme speichern kann und der von anderen Threads, die Instanzen von std::future oder std::shared_future besitzen, die auf diesen shared state verweisen, untersucht, abgewartet und anderweitig manipuliert werden kann.

Definiert im Header <future>
(C++11)
speichert einen Wert für asynchronen Abruf
(Klassen-Template)
(C++11)
kapselt eine Funktion, um ihren Rückgabewert für asynchronen Abruf zu speichern
(Klassen-Template)
(C++11)
wartet auf einen Wert, der asynchron gesetzt wird
(Klassen-Template)
(C++11)
wartet auf einen Wert (möglicherweise referenziert durch andere futures), der asynchron gesetzt wird
(Klassen-Template)
(C++11)
führt eine Funktion asynchron aus (möglicherweise in einem neuen Thread) und gibt ein std::future zurück, das das Ergebnis halten wird
(Funktions-Template)
(C++11)
spezifiziert die Start-Policy für std::async
(Enumeration)
(C++11)
spezifiziert die Ergebnisse von zeitgesteuerten Warteoperationen auf std::future und std::shared_future
(Enumeration)
Future-Fehler
(C++11)
meldet einen Fehler im Zusammenhang mit Futures oder Promises
(Klasse)
(C++11)
identifiziert die Future-Fehlerkategorie
(Funktion)
(C++11)
identifiziert die Future-Fehlercodes
(Enumeration)

Sichere Wiedergewinnung (since C++26)

Safe-Reclamation-Techniken werden am häufigsten verwendet, um Zugriffs-Lösch-Konflikte unkompliziert zu lösen.

Read-Copy-Update-Mechanismus
Definiert im Header <rcu>
(C++26)
ermöglicht es, ein Objekt durch RCU zu schützen
(Klassentemplate)
(C++26)
stellt Bereiche von RCU-Schutz bereit
(Klasse)
(C++26)
gibt eine Referenz auf ein Objekt mit statischer Lebensdauer vom Typ std::rcu_domain zurück
(Funktion)
(C++26)
blockiert, bis ein Schutzbereich auf einer RCU-Domain entsperrt wird
(Funktion)
(C++26)
kann geplante Operationen auf einer RCU-Domain auswerten und blockiert, bis alle vorherigen Auswertungen abgeschlossen sind
(Funktion)
(C++26)
plant die Auswertung einer spezifizierten Funktion auf einer RCU-Domain, potenziell mit Speicherallokation und Aufruf geplanter Auswertungen
(Funktionstemplate)
Hazard-Pointer
Definiert im Header <hazard_pointer>
(C++26)
ermöglicht es, ein Objekt hazard-geschützt zu machen
(Klassentemplate)
(C++26)
Single-Writer-Multi-Reader-Zeiger, der zu jedem Zeitpunkt von höchstens einem Thread besessen werden kann
(Klasse)
(C++26)
konstruiert einen Hazard-Pointer
(Funktion)

Siehe auch

C-Dokumentation für Concurrency support library