`<atomic>`

Artikel
10/12/2023

Definiert Klassen und Klassenvorlagen, die zum Erstellen von Typen verwendet werden sollen, die Atomoperationen unterstützen.

Syntax

#include <atomic>

Bemerkungen

Hinweis

In Code, der mithilfe von /clr:pure"Kompiliert" kompiliert wird, wird dieser Header blockiert. Beide /clr:pure Versionen sind in Visual Studio 2017 und /clr:safe höheren Versionen veraltet.

Ein atomer Vorgang verfügt über zwei Schlüsseleigenschaften, mit denen Sie mehrere Threads verwenden können, um ein Objekt ordnungsgemäß zu bearbeiten, ohne Sperren zu verwenden mutex .

Da eine atomische Operation unteilbar ist, kann eine zweite atomische Operation auf demselben Objekt aus einem anderen Thread den Zustand des Objekts nur vor oder nach der ersten atomischen Operation abrufen.
Basierend auf ihrem memory_order Argument legt eine atome Operation Die Ordnungsanforderungen für die Sichtbarkeit der Auswirkungen anderer atomer Operationen im selben Thread fest. Daher unterbindet dieser Vorgang Compileroptimierungen, die die Anforderungen für die Sortierung verletzen.

Auf manchen Plattformen ist es möglicherweise nicht möglich, atomische Vorgänge für bestimme Typen effizient zu implementieren, ohne mutex-Sperren zu verwenden. Ein atomer Typ ist lock-free , wenn keine Atomoperationen auf diesem Typ Sperren verwenden.

C++11: In Signalhandlern können Sie atome Operationen für ein Objekt obj ausführen, wenn obj.is_lock_free() oder atomic_is_lock_free(x) sind true.

Die Klasse atomic_flag stellt einen minimalen Atomtyp bereit, der eine bool Kennzeichnung enthält. Die Vorgänge sind immer sperrfrei.

Die Klassenvorlage atomic<T> speichert ein Objekt seines Argumenttyps T und ermöglicht den atombasierten Zugriff auf diesen gespeicherten Wert. Sie können sie instanziieren, indem Sie einen beliebigen Typ verwenden, der mithilfe von " memcpy Gleichheit" kopiert und auf Gleichheit memcmpgetestet werden kann. Sie können es insbesondere mit benutzerdefinierten Typen, die diese Anforderungen erfüllen, und oftmals auch mit Gleitkommatypen verwenden.

Die Vorlage verfügt über eine Reihe von Spezialisierungen für integrale Typen und eine Teilspezialisierung für Zeiger. Diese Spezialisierungen stellen zusätzliche Vorgänge bereit, die nicht über die primäre Vorlage verfügbar sind.

Zeigerspezialisierungen

Die Teilspezialisierung atomic<T *> gilt für alle Zeigertypen. Sie stellen Methoden für Zeigerarithmetik bereit.

Integrale Spezialisierungen

Die atomic<integral>-Spezialisierungen sind auf alle integralen Typen anwendbar. Sie stellen zusätzliche Vorgänge bereit, die nicht über die primäre Vorlage verfügbar sind.

Jeder atomic<integral>-Typ hat ein entsprechendes Makro, das Sie in if directive verwenden können, um beim Kompilieren festzustellen, ob Vorgänge für diesen Typ sperrfrei sind. Wenn der Wert des Makros null ist, werden Vorgänge für den Typ nicht gesperrt. Wenn der Wert 1 ist, sind Vorgänge möglicherweise sperrfrei. Dadurch ist eine Überprüfung der Laufzeit erforderlich. Wenn der Wert 2 ist, sind Vorgänge sperrfrei. Sie können mithilfe der Funktion atomic_is_lock_free zur Laufzeit bestimmen, ob Vorgänge für diesen Typ sperrfrei sind.

Für jeden integralen Typ gibt es einen entsprechenden benannten Atomtyp, der ein Objekt dieses integralen Typs verwaltet. Jeder atomic_integral-Typ hat den gleichen Satz von Memberfunktionen wie die entsprechende Instanziierung atomic<T>, und kann an die atomischen Funktionen übergeben werden, die nicht-Memberfunktionen sind.

`atomic_integral`-Typ	Integrale Typen	`atomic_is_lock_free`-Makro
`atomic_char`	`char`	`ATOMIC_CHAR_LOCK_FREE`
`atomic_schar`	`signed char`	`ATOMIC_CHAR_LOCK_FREE`
`atomic_uchar`	`unsigned char`	`ATOMIC_CHAR_LOCK_FREE`
`atomic_char16_t`	`char16_t`	`ATOMIC_CHAR16_T_LOCK_FREE`
`atomic_char32_t`	`char32_t`	`ATOMIC_CHAR32_T_LOCK_FREE`
`atomic_wchar_t`	`wchar_t`	`ATOMIC_WCHAR_T_LOCK_FREE`
`atomic_short`	`short`	`ATOMIC_SHORT_LOCK_FREE`
`atomic_ushort`	`unsigned short`	`ATOMIC_SHORT_LOCK_FREE`
`atomic_int`	`int`	`ATOMIC_INT_LOCK_FREE`
`atomic_uint`	`unsigned int`	`ATOMIC_INT_LOCK_FREE`
`atomic_long`	`long`	`ATOMIC_LONG_LOCK_FREE`
`atomic_ulong`	`unsigned long`	`ATOMIC_LONG_LOCK_FREE`
`atomic_llong`	`long long`	`ATOMIC_LLONG_LOCK_FREE`
`atomic_ullong`	`unsigned long long`	`ATOMIC_LLONG_LOCK_FREE`

Typedef Namen sind für Spezialisierungen der Atomvorlage für einige der Typen vorhanden, die in der Kopfzeile <inttypes.h>definiert sind.

Atomischer Typ	`Typedef` Name
`atomic_int8_t`	`atomic<int8_t>`
`atomic_uint8_t`	`atomic<uint8_t>`
`atomic_int16_t`	`atomic<int16_t>`
`atomic_uint16_t`	`atomic<uint16_t>`
`atomic_int32_t`	`atomic<int32_t>`
`atomic_uint32_t`	`atomic<uint32_t>`
`atomic_int64_t`	`atomic<int64_t>`
`atomic_uint64_t`	`atomic<uint64_t>`
`atomic_int_least8_t`	`atomic<int_least8_t>`
`atomic_uint_least8_t`	`atomic<uint_least8_t>`
`atomic_int_least16_t`	`atomic<int_least16_t>`
`atomic_uint_least16_t`	`atomic<uint_least16_t>`
`atomic_int_least32_t`	`atomic<int_least32_t>`
`atomic_uint_least32_t`	`atomic<uint_least32_t>`
`atomic_int_least64_t`	`atomic<int_least64_t>`
`atomic_uint_least64_t`	`atomic<uint_least64_t>`
`atomic_int_fast8_t`	`atomic<int_fast8_t>`
`atomic_uint_fast8_t`	`atomic<uint_fast8_t>`
`atomic_int_fast16_t`	`atomic<int_fast16_t>`
`atomic_uint_fast16_`	`atomic<uint_fast16_t>`
`atomic_int_fast32_t`	`atomic<int_fast32_t>`
`atomic_uint_fast32_t`	`atomic<uint_fast32_t>`
`atomic_int_fast64_t`	`atomic<int_fast64_t>`
`atomic_uint_fast64_t`	`atomic<uint_fast64_t>`
`atomic_intptr_t`	`atomic<intptr_t>`
`atomic_uintptr_t`	`atomic<uintptr_t>`
`atomic_size_t`	`atomic<size_t>`
`atomic_ptrdiff_t`	`atomic<ptrdiff_t>`
`atomic_intmax_t`	`atomic<intmax_t>`
`atomic_uintmax_t`	`atomic<uintmax_t>`

Strukturen

Name	Beschreibung
`atomic` Struktur	Beschreibt ein Objekt, das Vorgänge für einen gespeicherten Wert ausführt `atomic` .
`atomic_flag` Struktur	Beschreibt ein Objekt, das ein Flag `bool`-Flag atomisch festlegt und löscht.

Enumerationen

Name	Beschreibung
`memory_order` Enumeration	Stellt symbolische Namen für Synchronisierungsvorgänge auf Speicheradressen bereit. Diese Vorgänge wirken sich auf das Sichtbarwerden der Zuweisung eines Thread in einem anderen aus.

Functions

In der folgenden Liste enthalten die Funktionen, die nicht enden _explicit , die Semantik der entsprechenden _explicit, mit der Ausnahme, dass sie die impliziten memory_order Argumente von memory_order_seq_cst.

Name	Beschreibung
`atomic_compare_exchange_strong`	Führt einen `atomic compare and exchange` Vorgang aus.
`atomic_compare_exchange_strong_explicit`	Führt einen `atomic compare and exchange` Vorgang aus.
`atomic_compare_exchange_weak`	Führt einen `weak atomic compare and exchange` Vorgang aus.
`atomic_compare_exchange_weak_explicit`	Führt einen `weak atomic compare and exchange` Vorgang aus.
`atomic_exchange`	Ersetzt einen gespeicherten Wert.
`atomic_exchange_explicit`	Ersetzt einen gespeicherten Wert.
`atomic_fetch_add`	Fügt einem vorhandenen gespeicherten Wert einen angegebenen Wert hinzu.
`atomic_fetch_add_explicit`	Fügt einem vorhandenen gespeicherten Wert einen angegebenen Wert hinzu.
`atomic_fetch_and`	Führt ein bitweises "and" (`&`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_fetch_and_explicit`	Führt ein bitweises "and" (`&`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_fetch_or`	Führt ein bitweises "or" (`\|`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_fetch_or_explicit`	Führt ein bitweises "or" (`\|`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_fetch_sub`	Subtrahiert einen angegebenen Wert von einem vorhandenen gespeicherten Wert.
`atomic_fetch_sub_explicit`	Subtrahiert einen angegebenen Wert von einem vorhandenen gespeicherten Wert.
`atomic_fetch_xor`	Führt ein bitweises "exklusiv" oder (`^`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_fetch_xor_explicit`	Führt ein bitweises "exklusiv" oder (`^`) für einen angegebenen Wert und einen vorhandenen gespeicherten Wert aus.
`atomic_flag_clear`	Legt das Flag in einem `atomic_flag`-Objekt auf `false` fest.
`atomic_flag_clear_explicit`	Legt das Flag in einem `atomic_flag`-Objekt auf `false` fest.
`atomic_flag_test_and_set`	Legt das Flag in einem `atomic_flag`-Objekt auf `true` fest.
`atomic_flag_test_and_set_explicit`	Legt das Flag in einem `atomic_flag`-Objekt auf `true` fest.
`atomic_init`	Legt den gespeicherten Wert in einem `atomic`-Objekt fest.
`atomic_is_lock_free`	Gibt an, ob die atomischen Vorgänge auf einem bestimmten Objekt sperrfrei sind.
`atomic_load`	Ruft atomisch einen Wert ab.
`atomic_load_explicit`	Ruft atomisch einen Wert ab.
`atomic_signal_fence`	Dient als Eine `fence` Funktion zum Einrichten von Anforderungen an die Speicherordnung zwischen Zäunen in einem aufrufenden Thread mit Signalhandlern, die im selben Thread ausgeführt werden.
`atomic_store`	Speichert einen Wert atomisch.
`atomic_store_explicit`	Speichert einen Wert atomisch.
`atomic_thread_fence`	Dient als Eine `fence` , die Speicherordnungsanforderungen in Bezug auf andere Zäune festlegt.
`kill_dependency`	Unterbricht eine mögliche Abhängigkeitskette.

Siehe auch

Headerdateienreferenz
C++-Standardbibliotheksreferenz

Freigeben über