Concurrency support library (seit C++11)

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Concurrency support library (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für nebenläufige Programmierung

Threads thread (C++11) jthread (C++20) hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17) this_thread Namespace get_id (C++11) yield (C++11) sleep_for (C++11) sleep_until (C++11) Kooperatives Beenden stop_token (C++20) inplace_stop_token (C++26) never_stop_token (C++26) stop_source (C++20) inplace_stop_source (C++26)   stop_callback (C++20) inplace_stop_callback (C++26) stop_callback_for_t (C++26) stoppable_token (C++26) unstoppable_token (C++26) stoppable-source (C++26) stoppable-callback-for (C++26)   Gegenseitiger Ausschluss mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17) timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14) Allgemeines Sperrungsmanagement lock (C++11) lock_guard (C++11) scoped_lock (C++17) unique_lock (C++11) shared_lock (C++14) once_flag (C++11) call_once (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lockdefer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)(C++11)(C++11)(C++11) Bedingungsvariablen condition_variable (C++11) condition_variable_any (C++11) notify_all_at_thread_exit (C++11) cv_status (C++11) Semaphoren counting_semaphorebinary_semaphore (C++20)(C++20) Latches und Barriers latch (C++20) barrier (C++20) Futures promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11) launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11) Sichere Wiederherstellung rcu_obj_base (C++26) rcu_domain (C++26) rcu_default_domain (C++26) rcu_synchronize (C++26) rcu_barrier (C++26) rcu_retire (C++26) Hazard Pointer hazard_pointer_obj_base (C++26) hazard_pointer (C++26) make_hazard_pointer (C++26)

Atomare Typen atomic (C++11) atomic_ref (C++20) atomic_flag (C++11) Initialisierung von atomaren Typen atomic_init (C++11)(veraltet in C++20) ATOMIC_VAR_INIT (C++11)(veraltet in C++20) ATOMIC_FLAG_INIT (C++11) Speicherordnung memory_order (C++11) kill_dependency (C++11)(deprecated in C++26) atomic_thread_fence (C++11) atomic_signal_fence (C++11) Freie Funktionen für atomare Operationen atomic_storeatomic_store_explicit (C++11)(C++11) atomic_loadatomic_load_explicit (C++11)(C++11) atomic_exchangeatomic_exchange_explicit (C++11)(C++11) atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11) atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11) atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11) atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11) atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11) atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11) atomic_fetch_maxatomic_fetch_max_explicit (C++26)(C++26) atomic_fetch_minatomic_fetch_min_explicit (C++26)(C++26) atomic_is_lock_free (C++11) atomic_waitatomic_wait_explicit (C++20)(C++20) atomic_notify_one (C++20) atomic_notify_all (C++20) Freie Funktionen für atomare Flags atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11) atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11) atomic_flag_testatomic_flag_test_explicit (C++20)(C++20) atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20) atomic_flag_notify_one (C++20) atomic_flag_notify_all (C++20)

 

C++ enthält integrierte Unterstützung für Threads, atomare Operationen, gegenseitigen Ausschluss, Bedingungsvariablen und Futures.

Threads

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

Definiert in Header <thread>
thread (C++11)	verwaltet einen separaten Thread (Klasse)
jthread (C++20)	std::thread mit Unterstützung für automatische Wiederaufnahme und Abbruch (Klasse)
Funktionen zur Verwaltung des aktuellen Threads
Definiert im Namespace this_thread
yield (C++11)	legt nahe, dass die Implementierung die Ausführung von Threads neu plant (Funktion)
get_id (C++11)	gibt die Thread-ID des aktuellen Threads zurück (Funktion)
sleep_for (C++11)	stoppt die Ausführung des aktuellen Threads für eine angegebene Zeitdauer (Funktion)
sleep_until (C++11)	stoppt die Ausführung des aktuellen Threads bis zu einem angegebenen Zeitpunkt (Funktion)

Kooperatives Beenden (seit C++20)

Die Komponenten *Stop Source*, *Stop Token* und *Stop Callback* können verwendet werden, um asynchron anzufordern, dass eine Operation zeitnah stoppt, typischerweise weil das Ergebnis nicht mehr benötigt wird. Eine solche Anforderung wird als *Stop-Anforderung* bezeichnet.

Diese Komponenten spezifizieren die Semantik des gemeinsamen Zugriffs auf einen *Stop-Zustand*. Jedes Objekt, das eine dieser Komponenten modelliert und sich auf denselben Stop-Zustand bezieht, ist eine zugehörige Stop-Source, ein Stop-Token bzw. ein Stop-Callback.

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

(seit C++26)

Sie sind konzipiert

• um die Ausführung kooperativ abzubrechen, wie z.B. für std::jthread,
• um Wartefunktionen von std::condition_variable_any zu unterbrechen,

um ein gestopptes Abschließen einer durch execution::connect erstellten asynchronen Operation durchzuführen,

(seit C++26)

• oder für eine benutzerdefinierte Implementierung der Ausführungsverwaltung.

Tatsächlich müssen sie nicht einmal zum "Stoppen" von etwas verwendet werden, sondern können stattdessen beispielsweise für eine thread-sichere einmalige Auslösung von Funktionsaufrufen verwendet werden.

Definiert in Header <stop_token>
Stop-Token-Typen
stop_token (C++20)	eine Schnittstelle zur Abfrage, ob eine Abbruchanforderung von std::jthread gestellt wurde (Klasse)
never_stop_token (C++26)	stellt eine Stop-Token-Schnittstelle bereit, bei der ein Stoppen weder möglich noch angefordert ist (Klasse)
inplace_stop_token (C++26)	ein Stop-Token, das den Stop-Zustand seines zugehörigen std::inplace_stop_source-Objekts referenziert (Klasse)
Stop-Source-Typen
stop_source (C++20)	Klasse, die eine Anforderung darstellt, einen oder mehrere std::jthreads zu stoppen (Klasse)
inplace_stop_source (C++26)	eine stoppable-source, die alleiniger Eigentümer des Stop-Zustands ist (Klasse)
Stop-Callback-Typen
stop_callback (C++20)	eine Schnittstelle zur Registrierung von Callbacks bei der Abbruchanforderung von std::jthread (Klassen-Template)
inplace_stop_callback (C++26)	ein Stop-Callback für std::inplace_stop_token (Klassen-Template)
stop_callback_for_t (C++26)	ruft den Callback-Typ für einen gegebenen Stop-Token-Typ ab (Alias-Template)
Konzepte (seit C++20)
stoppable_token (C++26)	spezifiziert die grundlegende Schnittstelle von Stop-Tokens, die Abfragen für Stop-Anforderungen und die Möglichkeit des Stoppens erlaubt (Konzept)
unstoppable_token (C++26)	spezifiziert ein Stop-Token, das kein Stoppen erlaubt (Konzept)
stoppable-source (C++26)	spezifiziert, dass ein Typ eine Fabrik für zugehörige Stop-Tokens ist und eine Stop-Anforderung darauf erfolgen kann (nur zur Veranschaulichung verwendetes Konzept*)
stoppable-callback-for (C++26)	spezifiziert eine Schnittstelle zur Registrierung von Callbacks bei einem gegebenen Stop-Token-Typ (nur zur Veranschaulichung verwendetes Konzept*)

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

Definiert im Header <new>
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)	minimaler Abstand zur Vermeidung von False Sharing maximaler Abstand zur Förderung von True Sharing (Konstante)

Atomare Operationen

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

Definiert in Header <atomic>
Atomare Typen
atomic (C++11)	atomares Klassentemplate und Spezialisierungen für boolesche, integrale, Gleitkomma-(seit C++20) und Zeigertypen (Klassen-Template)
atomic_ref (C++20)	ermöglicht atomare Operationen auf nicht-atomaren Objekten (Klassen-Template)
Operationen auf atomaren Typen
atomic_is_lock_free (C++11)	prüft, ob die Operationen des atomaren Typs sperrfrei sind (Funktions-Template)
atomic_storeatomic_store_explicit (C++11)(C++11)	ersetzt atomar den Wert des atomaren Objekts durch ein nicht-atomares Argument (Funktions-Template)
atomic_loadatomic_load_explicit (C++11)(C++11)	liest atomar den Wert aus einem atomaren Objekt (Funktions-Template)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)	ersetzt atomar den Wert des atomaren Objekts durch ein nicht-atomares Argument und gibt den alten Wert des atomaren Objekts zurück (Funktions-Template)
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)	vergleicht atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument und führt bei Gleichheit einen atomaren Austausch oder bei Ungleichheit eine atomare Ladeoperation durch (Funktions-Template)
atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11)	addiert einen nicht-atomaren Wert zu einem atomaren Objekt und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)	subtrahiert einen nicht-atomaren Wert von einem atomaren Objekt und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11)	ersetzt das atomare Objekt durch das Ergebnis einer bitweisen AND-Operation mit einem nicht-atomaren Argument und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11)	ersetzt das atomare Objekt durch das Ergebnis einer bitweisen OR-Operation mit einem nicht-atomaren Argument und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11)	ersetzt das atomare Objekt durch das Ergebnis einer bitweisen XOR-Operation mit einem nicht-atomaren Argument und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_maxatomic_fetch_max_explicit (C++26)(C++26)	ersetzt das atomare Objekt durch das Ergebnis von std::max mit einem nicht-atomaren Argument und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_fetch_minatomic_fetch_min_explicit (C++26)(C++26)	ersetzt das atomare Objekt durch das Ergebnis von std::min mit einem nicht-atomaren Argument und gibt den vorherigen Wert des atomaren Objekts zurück (Funktions-Template)
atomic_waitatomic_wait_explicit (C++20)(C++20)	blockiert den Thread, bis er benachrichtigt wird und der atomare Wert sich ändert (Funktions-Template)
atomic_notify_one (C++20)	benachrichtigt einen Thread, der in atomic_wait blockiert ist (Funktions-Template)
atomic_notify_all (C++20)	benachrichtigt alle Threads, die in atomic_wait blockiert sind (Funktions-Template)
Flag-Typ und Operationen
atomic_flag (C++11)	der sperrfreie boolesche atomare Typ (Klasse)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)	setzt das Flag atomar auf true und gibt seinen vorherigen Wert zurück (Funktion)
atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)	setzt den Wert des Flags atomar auf false (Funktion)
atomic_flag_testatomic_flag_test_explicit (C++20)(C++20)	gibt den Wert des Flags atomar zurück (Funktion)
atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)	blockiert den Thread, bis er benachrichtigt wird und sich das Flag ändert (Funktion)
atomic_flag_notify_one (C++20)	benachrichtigt einen Thread, der in atomic_flag_wait blockiert ist (Funktion)
atomic_flag_notify_all (C++20)	benachrichtigt alle Threads, die in atomic_flag_wait blockiert sind (Funktion)
Initialisierung
atomic_init (C++11)(veraltet in C++20)	nicht-atomare Initialisierung eines standardmäßig konstruierten atomaren Objekts (Funktions-Template)
ATOMIC_VAR_INIT (C++11)(veraltet in C++20)	konstante Initialisierung einer atomaren Variable mit statischer Speicherdauer (Funktionsmakro)
ATOMIC_FLAG_INIT (C++11)	initialisiert ein std::atomic_flag auf false (Makro-Konstante)
Speichersynchronisationsordnung
memory_order (C++11)	definiert Speicherordnungseinschränkungen für die gegebene atomare Operation (Enum)
kill_dependency (C++11)(veraltet in C++26)	entfernt das angegebene Objekt aus dem Abhängigkeitsbaum von std::memory_order_consume (Funktions-Template)
atomic_thread_fence (C++11)	allgemeines speicherordnungsabhängiges Fence-Synchronisationsprimitiv (Funktion)
atomic_signal_fence (C++11)	Fence zwischen einem Thread und einem Signal-Handler, der im selben Thread ausgeführt wird (Funktion)
Definiert in Header <stdatomic.h>
C-kompatible Makros (seit C++23)
_Atomic (C++23)	kompatibles Makro, so dass _Atomic(T) identisch mit std::atomic<T> ist (Funktionsmakro)

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

Gegenseitiger Ausschluss

Algorithmen für gegenseitigen Ausschluss verhindern, dass mehrere Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen. Dies verhindert Datenrennen und bietet Unterstützung für die Synchronisation zwischen Threads.

Definiert in Header <mutex>
mutex (C++11)	bietet grundlegende Gegenseitiger-Ausschluss-Funktionen (Klasse)
timed_mutex (C++11)	bietet Gegenseitiger-Ausschluss-Funktionen, die ein Sperren mit Timeout implementieren (Klasse)
recursive_mutex (C++11)	bietet Gegenseitiger-Ausschluss-Funktionen, die von demselben Thread rekursiv gesperrt werden können (Klasse)
recursive_timed_mutex (C++11)	bietet Gegenseitiger-Ausschluss-Funktionen, die rekursiv gesperrt werden können von demselben Thread und implementiert ein Sperren mit Timeout (Klasse)
Definiert in Header <shared_mutex>
shared_mutex (C++17)	bietet gemeinsame Gegenseitiger-Ausschluss-Funktionen (Klasse)
shared_timed_mutex (C++14)	bietet gemeinsame Gegenseitiger-Ausschluss-Funktionen und implementiert ein Sperren mit Timeout (Klasse)
Allgemeines Sperrungsmanagement
Definiert in Header <mutex>
lock_guard (C++11)	implementiert einen streng bereichsbezogenen Mutex-Besitz-Wrapper (Klassen-Template)
scoped_lock (C++17)	todesfallsichere RAII-Hülle für mehrere Mutexe (Klassen-Template)
unique_lock (C++11)	implementiert verschiebbaren Mutex-Besitz-Wrapper (Klassenvorlage)
shared_lock (C++14)	implementiert verschiebbaren Shared-Mutex-Besitz-Wrapper (Klassenvorlage)
defer_locktry_to_lockadopt_lockdefer_lock_ttry_to_lock_tadopt_lock_t (C++11)	Tags zur Angabe der Sperrstrategie (Tag)
Generische Sperralgorithmen
try_lock (C++11)	versucht, den Besitz von Mutexen durch wiederholte Aufrufe von try_lock zu erlangen (Funktionsvorlage)
lock (C++11)	sperrt angegebene Mutexe, blockiert, wenn einer nicht verfügbar ist (Funktionsvorlage)
Einmaliger Aufruf
once_flag (C++11)	Hilfsobjekt, um sicherzustellen, dass call_once die Funktion nur einmal aufruft (Klasse)
call_once (C++11)	ruft eine Funktion nur einmal auf, auch wenn sie von mehreren Threads aufgerufen wird (Funktionsvorlage)

Bedingungsvariablen

Eine Bedingungsvariable ist ein Synchronisationsprimitiv, das es mehreren Threads ermöglicht, miteinander zu kommunizieren. Sie erlaubt einer bestimmten Anzahl von Threads, auf Benachrichtigungen von einem anderen Thread zu warten (möglicherweise mit einem Timeout), dass sie fortfahren dürfen. Eine Bedingungsvariable ist immer mit einem Mutex verbunden.

Definiert im Header <condition_variable>
condition_variable (C++11)	bietet eine Bedingungsvariable, die mit einem std::unique_lock verbunden ist (Klasse)
condition_variable_any (C++11)	bietet eine Bedingungsvariable, die mit jedem Sperrtyp verbunden ist (Klasse)
notify_all_at_thread_exit (C++11)	plant die Ausführung von notify_all, sobald dieser Thread vollständig beendet ist (Funktion)
cv_status (C++11)	listet die möglichen Ergebnisse von zeitgesteuerten Wartezeiten auf Bedingungsvariablen auf (Enum)

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 beides ausreicht, kann ein Semaphor effizienter sein als eine Bedingungsvariable.

Definiert im Header <semaphore>
counting_semaphore (C++20)	Semaphor, der eine nicht-negative Ressourcenanzahl modelliert (Klassenvorlage)
binary_semaphore (C++20)	Semaphor, der nur zwei Zustände hat (Typedef)

Latches und Barrieren (seit C++20)

Latches und Barrieren sind Mechanismen zur Thread-Koordination, 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 Barriere wiederholt verwendet werden kann.

Definiert im Header <latch>
latch (C++20)	einmalig verwendbare Thread-Barriere (Klasse)
Definiert im Header <barrier>
barrier (C++20)	wiederverwendbare Thread-Barriere (Klassenvorlage)

Futures

Die Standardbibliothek stellt Einrichtungen zur Verfügung, um Werte zu erhalten, die von asynchronen Aufgaben (d. h. in separaten Threads gestartete Funktionen) zurückgegeben werden, und um Ausnahmen abzufangen, die von diesen Aufgaben ausgelöst werden. Diese Werte werden in einem gemeinsamen Zustand übermittelt, in den 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 gemeinsamen Zustand verweisen, untersucht, auf den gewartet und der anderweitig manipuliert werden kann.

Definiert im Header <future>
promise (C++11)	speichert einen Wert zur asynchronen Abfrage (Klassenvorlage)
packaged_task (C++11)	paketiert eine Funktion, um ihren Rückgabewert zur asynchronen Abfrage zu speichern (Klassenvorlage)
future (C++11)	wartet auf einen Wert, der asynchron gesetzt wird (Klassenvorlage)
shared_future (C++11)	wartet auf einen Wert (möglicherweise von anderen Futures referenziert), der asynchron gesetzt wird (Klassenvorlage)
async (C++11)	führt eine Funktion asynchron aus (potenziell in einem neuen Thread) und gibt ein std::future zurück, das das Ergebnis enthalten wird (Funktionsvorlage)
launch (C++11)	spezifiziert die Startrichtlinie für std::async (Enum)
future_status (C++11)	spezifiziert die Ergebnisse von zeitgesteuerten Wartezeiten, die auf std::future und std::shared_future ausgeführt werden (Enum)
Future-Fehler
future_error (C++11)	meldet einen Fehler im Zusammenhang mit Futures oder Promises (Klasse)
future_category (C++11)	identifiziert die Future-Fehlerkategorie (Funktion)
future_errc (C++11)	identifiziert die Future-Fehlercodes (Enum)

Sichere Wiederherstellung (seit C++26)

Sichere Wiederherstellungstechniken werden am häufigsten verwendet, um Zugriffs-Lösch-Rennen (access-deletion races) auf einfache Weise zu lösen.

Read-Copy-Update-Mechanismus
Definiert im Header <rcu>
rcu_obj_base (C++26)	ermöglicht den Schutz eines Objekts durch RCU (Klassenvorlage)
rcu_domain (C++26)	stellt RCU-Schutzbereiche bereit (Klasse)
rcu_default_domain (C++26)	gibt eine Referenz auf ein statisches Objekt vom Typ std::rcu_domain zurück (Funktion)
rcu_synchronize (C++26)	blockiert, bis ein Schutzbereich in einer RCU-Domäne entsperrt wird (Funktion)
rcu_barrier (C++26)	kann geplante Operationen in einer RCU-Domäne auswerten und blockiert, bis alle vorherigen Auswertungen abgeschlossen sind (Funktion)
rcu_retire (C++26)	plant die Auswertung einer angegebenen Funktion in einer RCU-Domäne, weist möglicherweise Speicher zu und ruft geplante Auswertungen auf (Funktionsvorlage)
Hazard Pointer
Definiert im Header <hazard_pointer>
hazard_pointer_obj_base (C++26)	ermöglicht es einem Objekt, durch Hazard-Pointer geschützt zu werden (Klassenvorlage)
hazard_pointer (C++26)	Single-Writer-Multi-Reader-Zeiger, der zu jedem Zeitpunkt von höchstens einem Thread besessen werden kann (Klasse)
make_hazard_pointer (C++26)	konstruiert einen Hazard-Pointer (Funktion)

Siehe auch

C-Dokumentation für Bibliothek für nebenläufige Unterstützung