Namespaces
Variants

Concurrency support library

From cppreference.net
< c
C
Concurrency support library

C++ bietet eingebaute Unterstützung für Threads, atomare Operationen, gegenseitigen Ausschluss, Bedingungsvariablen und threadspezifische Speicher.

Diese Funktionen sind optional verfügbar:

  • falls die Makrokonstante __STDC_NO_THREADS__ vom Compiler definiert ist, werden der Header <threads.h> und alle darin bereitgestellten Namen nicht zur Verfügung gestellt;
  • falls die Makrokonstante __STDC_NO_ATOMICS__ vom Compiler definiert ist, werden der Header <stdatomic.h> und alle darin bereitgestellten Namen nicht zur Verfügung gestellt.

Siehe auch _Atomic type specifier and qualifier .

Inhaltsverzeichnis

Threads

Definiert im Header <threads.h>
thrd_t Implementierungsdefinierter vollständiger Objekttyp, der einen Thread identifiziert
(C11)
erstellt einen Thread
(Funktion)
(C11)
prüft, ob zwei Bezeichner auf denselben Thread verweisen
(Funktion)
(C11)
ermittelt den aktuellen Thread-Bezeichner
(Funktion)
(C11)
unterbricht die Ausführung des aufrufenden Threads für den angegebenen Zeitraum
(Funktion)
(C11)
gibt die aktuelle Zeitscheibe ab
(Funktion)
(C11)
beendet den aufrufenden Thread
(Funktion)
(C11)
trennt einen Thread
(Funktion)
(C11)
blockiert, bis ein Thread beendet wird
(Funktion)
(C11)
zeigt einen Thread-Fehlerstatus an
(Konstante)
thrd_start_t
(C11)
ein Typedef des Funktionszeigertyps int ( * ) ( void * ) , verwendet von thrd_create
(Typedef)

Atomare Operationen

Definiert im Header <stdatomic.h>
Operationen auf atomaren Typen
(C11)
gibt an, dass der gegebene atomare Typ sperrfrei ist
(Makrokonstante)
(C11)
gibt an, ob das atomare Objekt sperrfrei ist
(Funktion)
(C11)
speichert einen Wert in einem atomaren Objekt
(Funktion)
(C11)
liest einen Wert aus einem atomaren Objekt
(Funktion)
(C11)
tauscht einen Wert mit dem Wert eines atomaren Objekts aus
(Funktion)
(C11)
tauscht einen Wert mit einem atomaren Objekt aus, wenn der alte Wert den Erwartungen entspricht, andernfalls wird der alte Wert gelesen
(Funktion)
(C11)
Atomare Addition
(Funktion)
(C11)
Atomare Subtraktion
(Funktion)
(C11)
atomares bitweises ODER
(Funktion)
(C11)
atomares bitweises exklusives ODER
(Funktion)
(C11)
atomares bitweises UND
(Funktion)
Flag-Typ und Operationen
(C11)
Sperrfreie atomare boolesche Markierung
(struct)
(C11)
setzt ein atomic_flag auf true und gibt den vorherigen Wert zurück
(Funktion)
(C11)
setzt ein atomic_flag auf false
(Funktion)
Initialisierung
(C11)
initialisiert ein vorhandenes atomares Objekt
(Funktion)
(C11) (veraltet in C17) (entfernt in C23)
initialisiert ein neues atomares Objekt
(Funktionsmakro)
(C11)
initialisiert ein neues atomic_flag
(Makrokonstante)
Speicher-Synchronisierungsreihenfolge
(C11)
definiert Speicherreihenfolge-Einschränkungen
(enum)
(C11)
unterbricht eine Abhängigkeitskette für memory_order_consume
(Funktionsmakro)
(C11)
generische Speicherreihenfolgen-abhängige Fence-Synchronisationsprimitive
(Funktion)
(C11)
Zaun zwischen einem Thread und einem Signal-Handler, der im selben Thread ausgeführt wird
(Funktion)
Convenience-Type-Aliase
Typedef-Name Vollständiger Typname
atomic_bool (C11) _Atomic _Bool (bis C23) _Atomic bool (seit C23)
atomic_char (C11) _Atomic char
atomic_schar (C11) _Atomic signed char
atomic_uchar (C11) _Atomic unsigned char
atomic_short (C11) _Atomic short
atomic_ushort (C11) _Atomic unsigned short
atomic_int (C11) _Atomic int
atomic_uint (C11) _Atomic unsigned int
atomic_long (C11) _Atomic long
atomic_ulong (C11) _Atomic unsigned long
atomic_llong (C11) _Atomic long long
atomic_ullong (C11) _Atomic unsigned long long
atomic_char8_t (C23) _Atomic char8_t
atomic_char16_t (C11) _Atomic char16_t
atomic_char32_t (C11) _Atomic char32_t
atomic_wchar_t (C11) _Atomic wchar_t
atomic_int_least8_t (C11) _Atomic int_least8_t
atomic_uint_least8_t (C11) _Atomic uint_least8_t
atomic_int_least16_t (C11) _Atomic int_least16_t
atomic_uint_least16_t (C11) _Atomic uint_least16_t
atomic_int_least32_t (C11) _Atomic int_least32_t
atomic_uint_least32_t (C11) _Atomic uint_least32_t
atomic_int_least64_t (C11) _Atomic int_least64_t
atomic_uint_least64_t (C11) _Atomic uint_least64_t
atomic_int_fast8_t (C11) _Atomic int_fast8_t
atomic_uint_fast8_t (C11) _Atomic uint_fast8_t
atomic_int_fast16_t (C11) _Atomic int_fast16_t
atomic_uint_fast16_t (C11) _Atomic uint_fast16_t
atomic_int_fast32_t (C11) _Atomic int_fast32_t
atomic_uint_fast32_t (C11) _Atomic uint_fast32_t
atomic_int_fast64_t (C11) _Atomic int_fast64_t
atomic_uint_fast64_t (C11) _Atomic uint_fast64_t
atomic_intptr_t (C11) _Atomic intptr_t
atomic_uintptr_t (C11) _Atomic uintptr_t
atomic_size_t (C11) _Atomic size_t
atomic_ptrdiff_t (C11) _Atomic ptrdiff_t
atomic_intmax_t (C11) _Atomic intmax_t
atomic_uintmax_t (C11) _Atomic uintmax_t

Gegenseitiger Ausschluss

Definiert im Header <threads.h>
mtx_t Mutex-Kennung
(C11)
erstellt einen Mutex
(Funktion)
(C11)
blockiert bis ein Mutex gesperrt wird
(Funktion)
(C11)
blockiert bis ein Mutex gesperrt wird oder ein Timeout auftritt
(Funktion)
(C11)
sperrt einen Mutex oder kehrt zurück ohne zu blockieren falls bereits gesperrt
(Funktion)
(C11)
entsperrt einen Mutex
(Funktion)
(C11)
zerstört einen Mutex
(Funktion)
(C11) (C11) (C11)
definiert den Typ eines Mutex
(Enumeration)
Einmaliger Aufruf
(C11)
ruft eine Funktion genau einmal auf
(Funktion)

Bedingungsvariablen

Definiert in Header <threads.h>
cnd_t Bedingungsvariablen-Kennung
(C11)
erstellt eine Bedingungsvariable
(Funktion)
(C11)
entblockt einen auf eine Bedingungsvariable wartenden Thread
(Funktion)
(C11)
entblockt alle auf eine Bedingungsvariable wartenden Threads
(Funktion)
(C11)
blockiert auf einer Bedingungsvariable
(Funktion)
(C11)
blockiert auf einer Bedingungsvariable mit Timeout
(Funktion)
(C11)
zerstört eine Bedingungsvariable
(Funktion)

Thread-lokaler Speicher

Definiert im Header <threads.h>
(C11) (entfernt in C23)
Bequemlichkeitsmakro für Speicherklassenspezifizierer _Thread_local
(Schlüsselwort-Makro)
tss_t Thread-spezifischer Speicherzeiger
(C11)
Maximale Anzahl der Aufrufe von Destruktoren
(Makrokonstante)
tss_dtor_t
(C11)
Funktionszeigertyp void ( * ) ( void * ) , verwendet für TSS-Destruktor
(Typdefinition)
(C11)
erzeugt thread-spezifischen Speicherzeiger mit gegebenem Destruktor
(Funktion)
(C11)
liest aus thread-spezifischem Speicher
(Funktion)
(C11)
schreibt in thread-spezifischen Speicher
(Funktion)
(C11)
gibt die Ressourcen eines gegebenen thread-spezifischen Zeigers frei
(Funktion)

Reservierte Bezeichner

In zukünftigen Revisionen des C-Standards:

  • Funktionsnamen, Typnamen und Aufzählungskonstanten, die mit entweder cnd_ , mtx_ , thrd_ , oder tss_ beginnen und einem Kleinbuchstaben, können zu den Deklarationen im <threads.h> Header hinzugefügt werden;
  • Makros, die mit ATOMIC_ und einem Großbuchstaben beginnen, können zu den in der <stdatomic.h> Header definierten Makros hinzugefügt werden;
  • Typdefinitionnamen, die mit entweder atomic_ oder memory_ beginnen und einem Kleinbuchstaben, können zu den Deklarationen im <stdatomic.h> Header hinzugefügt werden;
  • Aufzählungskonstanten, die mit memory_order_ und einem Kleinbuchstaben beginnen, können zur Definition des memory_order Typs im <stdatomic.h> Header hinzugefügt werden;
  • Funktionsnamen, die mit atomic_ und einem Kleinbuchstaben beginnen, können zu den Deklarationen im <stdatomic.h> Header hinzugefügt werden.

Für Funktionsnamen reservierte Bezeichner sind stets potenziell (since C23) für die Verwendung als Bezeichner mit externer Bindung reserviert, während andere hier aufgeführte Bezeichner potenziell (since C23) reserviert sind, wenn <stdatomic.h> eingebunden wird.

Das Deklarieren, Definieren oder #undef -Anwenden eines solchen Identifikators führt zu undefiniertem Verhalten wenn er durch den Standard oder die Implementierung bereitgestellt wird (seit C23) . Portierbare Programme sollten diese Identifikatoren nicht verwenden.

Referenzen

  • C23-Standard (ISO/IEC 9899:2024):
  • 7.17 Atomics <stdatomic.h> (S.: TBD)
  • 7.26 Threads <threads.h> (S.: TBD)
  • 7.31.8 Atomics <stdatomic.h> (S.: TBD)
  • 7.31.15 Threads <threads.h> (S.: TBD)
  • C17-Standard (ISO/IEC 9899:2018):
  • 7.17 Atomics <stdatomic.h> (S. 200-209)
  • 7.26 Threads <threads.h> (S. 274-283)
  • 7.31.8 Atomics <stdatomic.h> (S. 332)
  • 7.31.15 Threads <threads.h> (S. 333)
  • C11-Standard (ISO/IEC 9899:2011):
  • 7.17 Atomics <stdatomic.h> (S. 273-286)
  • 7.26 Threads <threads.h> (S. 376-387)
  • 7.31.8 Atomics <stdatomic.h> (S. 455-456)
  • 7.31.15 Threads <threads.h> (S. 456)

Siehe auch

C++-Dokumentation für Concurrency Support Library

Externe Links

GNU GCC Libc Handbuch: ISO C Mutexes