Bibliothek für nebenläufige Programmierung

 

C

Compiler-Unterstützung

Sprache

Header

Typunterstützung

Programm-Dienstprogramme

Unterstützung für variable Funktionsargumente

Fehlerbehandlung

Dynamische Speicherverwaltung

Bibliothek für Zeichenketten

Algorithmen

Numerik

Datums- und Zeitdienstprogramme

Ein-/Ausgabeunterstützung

Lokalisierungsunterstützung

Unterstützung für Nebenläufigkeit (C11)

Technische Spezifikationen

Symbolindex

 

Bibliothek für nebenläufige Programmierung

Threads thrd_create thrd_equal thrd_current    thrd_sleep thrd_yield thrd_exit thrd_detach thrd_join thrd_successthrd_timedoutthrd_busythrd_nomemthrd_error    Atomare Operationen atomic_init ATOMIC_VAR_INIT (bis C23) ATOMIC_***_LOCK_FREE atomic_is_lock_free atomic_store atomic_load atomic_exchange atomic_compare_exchange atomic_fetch_add atomic_fetch_sub atomic_fetch_or atomic_fetch_xor atomic_fetch_and

Atomare Flags atomic_flag ATOMIC_FLAG_INIT atomic_flag_test_and_set atomic_flag_clear Speicherordnung memory_order kill_dependency atomic_thread_fence atomic_signal_fence Gegenseitiger Ausschluss mtx_init mtx_lock mtx_timedlock mtx_trylock call_once mtx_unlock mtx_destroy mtx_plainmtx_recursivemtx_timed Bedingungsvariablen cnd_init cnd_signal cnd_broadcast cnd_wait cnd_timedwait cnd_destroy Thread-lokaler Speicher thread_local TSS_DTOR_ITERATIONS    tss_create tss_get tss_set tss_delete

 

C enthält integrierte Unterstützung für Threads, atomare Operationen, gegenseitigen Ausschluss, Bedingungsvariablen und Thread-spezifischen Speicher.

Diese Funktionen werden optional bereitgestellt

• wenn die Makrokonstante __STDC_NO_THREADS__ vom Compiler definiert ist, sind die Headerdatei <threads.h> und alle darin enthaltenen Namen nicht verfügbar;
• wenn die Makrokonstante __STDC_NO_ATOMICS__ vom Compiler definiert ist, sind die Headerdatei <stdatomic.h> und alle darin enthaltenen Namen nicht verfügbar.

Siehe auch _Atomic Typ-Spezifizierer und Qualifier.

Threads

Definiert im Header <threads.h>
thrd_t	implementierungsabhängiger vollständiger Objekttyp zur Identifizierung eines Threads
thrd_create (C11)	erzeugt einen Thread (Funktion)
thrd_equal (C11)	prüft, ob zwei Bezeichner auf denselben Thread verweisen (Funktion)
thrd_current (C11)	erhält die Kennung des aktuellen Threads (Funktion)
thrd_sleep (C11)	setzt die Ausführung des aufrufenden Threads für die angegebene Zeitspanne aus (Funktion)
thrd_yield (C11)	gibt den aktuellen Zeitschlitz frei (Funktion)
thrd_exit (C11)	beendet den aufrufenden Thread (Funktion)
thrd_detach (C11)	trennt einen Thread ab (Funktion)
thrd_join (C11)	blockiert, bis ein Thread beendet wird (Funktion)
thrd_successthrd_timedoutthrd_busythrd_nomemthrd_error (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
ATOMIC_BOOL_LOCK_FREEATOMIC_CHAR_LOCK_FREEATOMIC_CHAR16_T_LOCK_FREEATOMIC_CHAR32_T_LOCK_FREEATOMIC_WCHAR_T_LOCK_FREEATOMIC_SHORT_LOCK_FREEATOMIC_INT_LOCK_FREEATOMIC_LONG_LOCK_FREEATOMIC_LLONG_LOCK_FREEATOMIC_POINTER_LOCK_FREE (C11)	zeigt an, dass der gegebene atomare Typ sperrfrei ist (Makro-Konstante)
atomic_is_lock_free (C11)	zeigt an, ob das atomare Objekt sperrfrei ist (Funktion)
atomic_storeatomic_store_explicit (C11)	speichert einen Wert in einem atomaren Objekt (Funktion)
atomic_loadatomic_load_explicit (C11)	liest einen Wert aus einem atomaren Objekt (Funktion)
atomic_exchangeatomic_exchange_explicit (C11)	tauscht einen Wert mit dem Wert eines atomaren Objekts aus (Funktion)
atomic_compare_exchange_strongatomic_compare_exchange_strong_explicitatomic_compare_exchange_weakatomic_compare_exchange_weak_explicit (C11)	tauscht einen Wert mit einem atomaren Objekt aus, wenn der alte Wert der erwartete ist, andernfalls liest er den alten Wert (Funktion)
atomic_fetch_addatomic_fetch_add_explicit (C11)	atomare Addition (Funktion)
atomic_fetch_subatomic_fetch_sub_explicit (C11)	atomare Subtraktion (Funktion)
atomic_fetch_oratomic_fetch_or_explicit (C11)	atomares bitweises ODER (Funktion)
atomic_fetch_xoratomic_fetch_xor_explicit (C11)	atomares bitweises exklusives ODER (Funktion)
atomic_fetch_andatomic_fetch_and_explicit (C11)	atomares bitweises UND (Funktion)
Flag-Typ und Operationen
atomic_flag (C11)	sperrfreies atomares boolesches Flag (Struktur)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C11)	setzt ein atomic_flag auf true und gibt den alten Wert zurück (Funktion)
atomic_flag_clearatomic_flag_clear_explicit (C11)	setzt ein atomic_flag auf false (Funktion)
Initialisierung
atomic_init (C11)	initialisiert ein vorhandenes atomares Objekt (Funktion)
ATOMIC_VAR_INIT (C11)(veraltet in C17)(entfernt in C23)	initialisiert ein neues atomares Objekt (Makro-Funktion)
ATOMIC_FLAG_INIT (C11)	initialisiert ein neues atomic_flag (Makro-Konstante)
Speichersynchronisationsordnung
memory_order (C11)	definiert Speicherreihenfolgebeschränkungen (Enum)
kill_dependency (C11)	bricht eine Abhängigkeitskette für memory_order_consume (Makro-Funktion)
atomic_thread_fence (C11)	allgemeines speicherordnungsabhängiges Fence-Synchronisationsprimitiv (Funktion)
atomic_signal_fence (C11)	Fence zwischen einem Thread und einem Signal-Handler, der im selben Thread ausgeführt wird (Funktion)

Komfortable Typ-Aliase
Typedef-Name	Vollständiger Typ-Name
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
mtx_init (C11)	erzeugt einen Mutex (Funktion)
mtx_lock (C11)	blockiert, bis ein Mutex gesperrt ist (Funktion)
mtx_timedlock (C11)	blockiert, bis ein Mutex gesperrt ist, oder läuft ab (Funktion)
mtx_trylock (C11)	sperrt einen Mutex oder kehrt zurück, ohne zu blockieren, wenn er bereits gesperrt ist (Funktion)
mtx_unlock (C11)	entsperrt einen Mutex (Funktion)
mtx_destroy (C11)	zerstört einen Mutex (Funktion)
mtx_plainmtx_recursivemtx_timed (C11)(C11)(C11)	definiert den Typ eines Mutex (Enum)
Einmaliger Aufruf
call_once (C11)	ruft eine Funktion genau einmal auf (Funktion)

Bedingungsvariablen

Definiert im Header <threads.h>
cnd_t	Kennung der Bedingungsvariable
cnd_init (C11)	erzeugt eine Bedingungsvariable (Funktion)
cnd_signal (C11)	entblockiert einen Thread, der auf eine Bedingungsvariable wartet (Funktion)
cnd_broadcast (C11)	entblockiert alle Threads, die auf eine Bedingungsvariable warten (Funktion)
cnd_wait (C11)	blockiert auf einer Bedingungsvariable (Funktion)
cnd_timedwait (C11)	blockiert auf einer Bedingungsvariable mit Timeout (Funktion)
cnd_destroy (C11)	zerstört eine Bedingungsvariable (Funktion)

Thread-lokaler Speicher

Definiert im Header <threads.h>
thread_local (C11)(entfernt in C23)	Komfort-Makro für den Storage-Class-Spezifizierer _Thread_local (Keyword-Makro)
tss_t	Thread-spezifischer Speicherzeiger
TSS_DTOR_ITERATIONS (C11)	maximale Anzahl von Aufrufen der Destruktoren (Makro-Konstante)
tss_dtor_t (C11)	Funktionszeigertyp void(*)(void*), verwendet für TSS-Destruktoren (typedef)
tss_create (C11)	erzeugt einen thread-spezifischen Speicherzeiger mit einem gegebenen Destruktor (Funktion)
tss_get (C11)	liest aus dem thread-spezifischen Speicher (Funktion)
tss_set (C11)	schreibt in den thread-spezifischen Speicher (Funktion)
tss_delete (C11)	gibt die Ressourcen frei, die von einem gegebenen thread-spezifischen Zeiger gehalten werden (Funktion)

Reservierte Bezeichner

In zukünftigen Revisionen des C-Standards

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

Bezeichner, die für Funktionsnamen reserviert sind, sind immer potenziell(seit C23) für die Verwendung als Bezeichner mit externer Verknüpfung reserviert, während andere hier aufgeführte Bezeichner potenziell(seit C23) reserviert sind, wenn <stdatomic.h> eingebunden wird.

Das Deklarieren, Definieren oder #undefen eines solchen Bezeichners führt zu undefiniertem Verhalten wenn er vom Standard oder der Implementierung bereitgestellt wird(seit C23). Portierbare Programme sollten diese Bezeichner 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 Unterstützung für Nebenläufigkeit-Bibliothek

Externe Links

GNU GCC Libc Manual: ISO C Mutexe