QAtomicInteger Class
template <typename T> class QAtomicIntegerDie Klasse QAtomicInteger bietet plattformunabhängige atomare Operationen auf Ganzzahlen. Mehr...
Kopfzeile: | #include <QAtomicInteger> |
CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
qmake: | QT += core |
Vererbt von: |
- Liste aller Member, einschließlich geerbter Member
- QAtomicInteger ist Teil der Threading-Klassen.
Öffentliche Funktionen
QAtomicInteger(T value = 0) | |
QAtomicInteger(const QAtomicInteger<T> &other) | |
bool | deref() |
T | fetchAndAddAcquire(T valueToAdd) |
T | fetchAndAddOrdered(T valueToAdd) |
T | fetchAndAddRelaxed(T valueToAdd) |
T | fetchAndAddRelease(T valueToAdd) |
T | fetchAndAndAcquire(T valueToAnd) |
T | fetchAndAndOrdered(T valueToAnd) |
T | fetchAndAndRelaxed(T valueToAnd) |
T | fetchAndAndRelease(T valueToAnd) |
T | fetchAndOrAcquire(T valueToOr) |
T | fetchAndOrOrdered(T valueToOr) |
T | fetchAndOrRelaxed(T valueToOr) |
T | fetchAndOrRelease(T valueToOr) |
T | fetchAndStoreAcquire(T newValue) |
T | fetchAndStoreOrdered(T newValue) |
T | fetchAndStoreRelaxed(T newValue) |
T | fetchAndStoreRelease(T newValue) |
T | fetchAndSubAcquire(T valueToSub) |
T | fetchAndSubOrdered(T valueToSub) |
T | fetchAndSubRelaxed(T valueToSub) |
T | fetchAndSubRelease(T valueToSub) |
T | fetchAndXorAcquire(T valueToXor) |
T | fetchAndXorOrdered(T valueToXor) |
T | fetchAndXorRelaxed(T valueToXor) |
T | fetchAndXorRelease(T valueToXor) |
T | loadAcquire() const |
T | loadRelaxed() const |
bool | ref() |
void | storeRelaxed(T newValue) |
void | storeRelease(T newValue) |
bool | testAndSetAcquire(T expectedValue, T newValue) |
bool | testAndSetAcquire(T expectedValue, T newValue, T ¤tValue) |
bool | testAndSetOrdered(T expectedValue, T newValue) |
bool | testAndSetOrdered(T expectedValue, T newValue, T ¤tValue) |
bool | testAndSetRelaxed(T expectedValue, T newValue) |
bool | testAndSetRelaxed(T expectedValue, T newValue, T ¤tValue) |
bool | testAndSetRelease(T expectedValue, T newValue) |
bool | testAndSetRelease(T expectedValue, T newValue, T ¤tValue) |
T | operator T() const |
T | operator&=(T value) |
T | operator++() |
T | operator++(int) |
T | operator+=(T value) |
T | operator--() |
T | operator--(int) |
T | operator-=(T value) |
QAtomicInteger<T> & | operator=(T) |
QAtomicInteger<T> & | operator=(const QAtomicInteger<T> &other) |
T | operator^=(T value) |
T | operator|=(T value) |
Statische öffentliche Mitglieder
bool | isFetchAndAddNative() |
bool | isFetchAndAddWaitFree() |
bool | isFetchAndStoreNative() |
bool | isFetchAndStoreWaitFree() |
bool | isReferenceCountingNative() |
bool | isReferenceCountingWaitFree() |
bool | isTestAndSetNative() |
bool | isTestAndSetWaitFree() |
Verwandte Nicht-Mitglieder
(since 6.7) void | qYieldCpu() |
Makros
Detaillierte Beschreibung
Für atomare Operationen auf Zeiger, siehe die Klasse QAtomicPointer.
Eine atomare Operation ist eine komplexe Operation, die ohne Unterbrechung abgeschlossen wird. Die Klasse QAtomicInteger bietet atomare Referenzzählung, test-and-set, fetch-and-store und fetch-and-add für Ganzzahlen.
Der Template-Parameter T
muss ein C++-Integer-Typ sein:
- 8-Bit: bool, char, signed char, unsigned char, qint8, quint8, char8_t (C++20)
- 16-Bit: short, unsigned short, qint16, quint16, char16_t
- 32-Bit: int, int ohne Vorzeichen, qint32, quint32, char32_t
- 64-Bit: long long, unsigned long long, qint64, quint64
- Plattformspezifische Größe: long, unsigned long
- Zeigergröße: qintptr, quintptr, qptrdiff
Von der obigen Liste funktionieren nur die 8-Bit-, 16-Bit-, 32-Bit- und Zeigergrößen-Instanziierungen garantiert auf allen Plattformen. Die Unterstützung für andere Größen hängt von dem Compiler und der Prozessorarchitektur ab, für die der Code kompiliert wird. Um zu testen, ob die 64-Bit-Typen auf 32-Bit-Plattformen unterstützt werden, prüfen Sie das Makro Q_ATOMIC_INT64_IS_SUPPORTED
.
Die Atomic-API
Referenzzählung
Die Funktionen ref() und deref() bieten eine effiziente API für die Referenzzählung. Der Rückgabewert dieser Funktionen wird verwendet, um anzuzeigen, wann die letzte Referenz freigegeben wurde. Mit diesen Funktionen können Sie Ihre eigenen implizit gemeinsam genutzten Klassen implementieren.
MySharedType &MySharedType::operator=(const MySharedType &other) { (void) other.data->atomicInt.ref(); if (!data->atomicInt.deref()) { // The last reference has been released delete d; } d = other.d; return *this; }
Speicherordnung
QAtomicInteger bietet mehrere Implementierungen der atomaren Funktionen test-and-set, fetch-and-store und fetch-and-add. Jede Implementierung definiert eine Speicherordnungssemantik, die beschreibt, wie Speicherzugriffe, die die atomare Anweisung umgeben, vom Prozessor ausgeführt werden. Da viele moderne Architekturen eine Ausführung außerhalb der Reihenfolge und eine Speicherordnung zulassen, ist die Verwendung der richtigen Semantik erforderlich, um sicherzustellen, dass Ihre Anwendung auf allen Prozessoren ordnungsgemäß funktioniert.
- Relaxed - die Speicherreihenfolge ist nicht spezifiziert und überlässt es dem Compiler und dem Prozessor, die Reihenfolge der Speicherzugriffe frei zu wählen.
- Acquire - Speicherzugriffe nach der atomaren Operation (in Programmreihenfolge) dürfen vor der atomaren Operation nicht neu geordnet werden.
- Release - Speicherzugriffe vor der atomaren Operation (in der Programmreihenfolge) dürfen nach der atomaren Operation nicht neu geordnet werden.
- Geordnet - die gleiche Semantik von Acquire und Release kombiniert.
Testen und Einstellen
Wenn der aktuelle Wert der QAtomicInteger ein erwarteter Wert ist, weisen die test-and-set Funktionen der QAtomicInteger einen neuen Wert zu und geben true zurück. Wenn die Werte not gleich sind, tun diese Funktionen nichts und geben false zurück. Dieser Vorgang entspricht dem folgenden Code:
if (currentValue == expectedValue) { currentValue = newValue; return true; } return false;
Es gibt 4 test-and-set Funktionen: testAndSetRelaxed(), testAndSetAcquire(), testAndSetRelease() und testAndSetOrdered(). Siehe oben für eine Erklärung der verschiedenen Speicherordnungssemantiken.
Holen-und-Speichern
Die atomaren fetch-and-store-Funktionen lesen den aktuellen Wert der QAtomicInteger, weisen dann einen neuen Wert zu und geben den ursprünglichen Wert zurück. Diese Operation entspricht dem folgenden Code:
int originalValue = currentValue; currentValue = newValue; return originalValue;
Es gibt 4 fetch-and-store-Funktionen: fetchAndStoreRelaxed(), fetchAndStoreAcquire(), fetchAndStoreRelease() und fetchAndStoreOrdered(). Siehe oben für eine Erklärung der verschiedenen Speicherordnungssemantiken.
Fetch-and-add
Die atomaren fetch-and-add-Funktionen lesen den aktuellen Wert der QAtomicInteger und addieren dann den angegebenen Wert zum aktuellen Wert und geben den ursprünglichen Wert zurück. Diese Operation entspricht dem folgenden Code:
int originalValue = currentValue; currentValue += valueToAdd; return originalValue;
Es gibt 4 fetch-and-add Funktionen: fetchAndAddRelaxed(), fetchAndAddAcquire(), fetchAndAddRelease(), und fetchAndAddOrdered(). Siehe oben für eine Erklärung der verschiedenen Speicherordnungssemantiken.
Funktionstests für die atomare API
Die Bereitstellung einer plattformunabhängigen atomaren API, die auf allen Prozessoren funktioniert, ist eine Herausforderung. Die von QAtomicInteger bereitgestellte API funktioniert garantiert atomar auf allen Prozessoren. Da jedoch nicht alle Prozessoren die Unterstützung für jede von QAtomicInteger bereitgestellte Operation implementieren, ist es notwendig, Informationen über den Prozessor offenzulegen.
Sie können zur Kompilierzeit überprüfen, welche Funktionen auf Ihrer Hardware unterstützt werden, indem Sie verschiedene Makros verwenden. Diese sagen Ihnen, ob Ihre Hardware eine bestimmte Operation immer, manchmal oder gar nicht unterstützt. Die Makros haben die Form Q_ATOMIC_INTnn_OPERATION_IS_HOW_NATIVE. nn ist die Größe der Ganzzahl (in Bits), OPERATION ist eine von REFERENCE_COUNTING, TEST_AND_SET, FETCH_AND_STORE, oder FETCH_AND_ADD, und HOW ist eine von ALWAYS, SOMETIMES, oder NOT. Es wird immer genau ein definiertes Makro pro Operation geben. Wenn zum Beispiel Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_ALWAYS_NATIVE definiert ist, wird weder Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE noch Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_NOT_NATIVE definiert.
Eine Operation, die in konstanter Zeit abgeschlossen wird, wird als wartungsfrei bezeichnet. Solche Operationen werden nicht mit Sperren oder Schleifen jeglicher Art implementiert. Für atomare Operationen, die immer unterstützt werden und wartungsfrei sind, definiert Qt die Q_ATOMIC_INTnn_OPERATION_IS_WAIT_FREE zusätzlich zu Q_ATOMIC_INTnn_OPERATION_IS_ALWAYS_NATIVE.
In Fällen, in denen eine atomare Operation nur von neueren Prozessorgenerationen unterstützt wird, bietet QAtomicInteger mit den Funktionen isReferenceCountingNative(), isTestAndSetNative(), isFetchAndStoreNative() und isFetchAndAddNative() auch eine Möglichkeit, zur Laufzeit zu prüfen, was die Hardware unterstützt. Wartefreie Implementierungen können mit den Funktionen isReferenceCountingWaitFree(), isTestAndSetWaitFree(), isFetchAndStoreWaitFree() und isFetchAndAddWaitFree() erkannt werden.
Im Folgenden finden Sie eine vollständige Liste aller Feature-Makros für QAtomicInteger:
- Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
- Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE
- Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_NOT_NATIVE
- Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_WAIT_FREE
- Q_ATOMIC_INTnn_TEST_AND_SET_IS_ALWAYS_NATIVE
- Q_ATOMIC_INTnn_TEST_AND_SET_IS_SOMETIMES_NATIVE
- Q_ATOMIC_INTnn_TEST_AND_SET_IS_NOT_NATIVE
- Q_ATOMIC_INTnn_TEST_AND_SET_IS_WAIT_FREE
- Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_NOT_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_WAIT_FREE
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_ALWAYS_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_NOT_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_WAIT_FREE
Aus Gründen der Kompatibilität mit früheren Versionen von Qt sind Makros mit einem leeren nn äquivalent zu den 32-Bit-Makros. Zum Beispiel ist Q_ATOMIC_INT_REFERENCE_COUNTING_IS_WAIT_FREE das gleiche wie Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_WAIT_FREE.
Siehe auch QAtomicPointer.
Dokumentation der Mitgliedsfunktionen
[constexpr noexcept]
QAtomicInteger::QAtomicInteger(T value = 0)
Konstruiert eine QAtomicInteger mit der angegebenen value.
[noexcept]
QAtomicInteger::QAtomicInteger(const QAtomicInteger<T> &other)
Konstruiert eine Kopie von other.
bool QAtomicInteger::deref()
Dekrementiert atomar den Wert dieses QAtomicInteger. Gibt true
zurück, wenn der neue Wert ungleich Null ist, andernfalls false.
Diese Funktion verwendet die geordnete memory ordering Semantik, die sicherstellt, dass Speicherzugriffe vor und nach der atomaren Operation (in Programmreihenfolge) nicht neu geordnet werden können.
Siehe auch ref() und operator--().
T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)
Atomares Holen und Hinzufügen.
Liest den aktuellen Wert von QAtomicInteger und addiert dann valueToAdd zum aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der auf die atomare Operation folgende Speicherzugriff (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
Siehe auch operator+=() und fetchAndSubAcquire().
T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)
Atomares Holen und Hinzufügen.
Liest den aktuellen Wert dieses QAtomicInteger und addiert dann valueToAdd zum aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine geordnete memory ordering Semantik, die sicherstellt, dass die Speicherzugriffe vor und nach der atomaren Operation (in der Programmreihenfolge) nicht neu geordnet werden können.
Siehe auch operator+=() und fetchAndSubOrdered().
T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)
Atomares Holen und Hinzufügen.
Liest den aktuellen Wert von QAtomicInteger und addiert dann valueToAdd zum aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe frei zu ordnen.
Siehe auch operator+=() und fetchAndSubRelaxed().
T QAtomicInteger::fetchAndAddRelease(T valueToAdd)
Atomares Holen und Hinzufügen.
Liest den aktuellen Wert dieses QAtomicInteger und addiert dann valueToAdd zum aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik release memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
Siehe auch operator+=() und fetchAndSubRelease().
T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)
Atomarer Abruf-und-und.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToAnd bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der auf die atomare Operation folgende Speicherzugriff (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
Siehe auch operator&=().
T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)
Atomarer Abruf-und-und.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToAnd bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die geordnete memory ordering Semantik, die sicherstellt, dass die Speicherzugriffe vor und nach der atomaren Operation (in Programmreihenfolge) nicht neu geordnet werden können.
Siehe auch operator&=().
T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)
Atomarer Abruf-und-und.
Liest den aktuellen Wert dieser QAtomicInteger und verknüpft dann valueToAnd bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe neu zu ordnen.
Siehe auch operator&=().
T QAtomicInteger::fetchAndAndRelease(T valueToAnd)
Atomarer Abruf-und-und.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToAnd bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von release memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in der Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
Siehe auch operator&=().
T QAtomicInteger::fetchAndOrAcquire(T valueToOr)
Atomares Holen-und-Oder.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToOr bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der auf die atomare Operation folgende Speicherzugriff (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
Siehe auch operator|=().
T QAtomicInteger::fetchAndOrOrdered(T valueToOr)
Atomares Holen-und-Oder.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToOr bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in Programmreihenfolge) nicht neu geordnet werden kann.
Siehe auch operator|=().
T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)
Atomares Holen-und-Oder.
Liest den aktuellen Wert dieser QAtomicInteger und verknüpft dann valueToOr bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik und überlässt es dem Compiler und dem Prozessor, die Speicherzugriffe frei zu ordnen.
Siehe auch operator|=().
T QAtomicInteger::fetchAndOrRelease(T valueToOr)
Atomares Holen-und-Oder.
Liest den aktuellen Wert dieses QAtomicInteger und verknüpft dann valueToOr bitweise mit dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von release memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden darf.
Siehe auch operator|=().
T QAtomicInteger::fetchAndStoreAcquire(T newValue)
Atomares Holen und Speichern.
Liest den aktuellen Wert dieses QAtomicInteger und weist ihm dann den newValue zu und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der Speicherzugriff nach der atomaren Operation (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
T QAtomicInteger::fetchAndStoreOrdered(T newValue)
Atomares Holen und Speichern.
Liest den aktuellen Wert dieses QAtomicInteger und weist ihm dann den newValue zu und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in der Reihenfolge des Programms) nicht neu geordnet werden kann.
T QAtomicInteger::fetchAndStoreRelaxed(T newValue)
Atomares Holen und Speichern.
Liest den aktuellen Wert dieses QAtomicInteger und weist ihm dann den newValue zu, wobei der ursprüngliche Wert zurückgegeben wird.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe frei zu ordnen.
T QAtomicInteger::fetchAndStoreRelease(T newValue)
Atomares Holen und Speichern.
Liest den aktuellen Wert dieses QAtomicInteger und weist ihm dann den newValue zu und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik der Freigabe memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in der Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
T QAtomicInteger::fetchAndSubAcquire(T valueToSub)
Atomares Holen-und-Sub.
Liest den aktuellen Wert dieses QAtomicInteger und subtrahiert dann valueToSub von dem aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der Speicherzugriff nach der atomaren Operation (in der Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
Siehe auch operator-=() und fetchAndAddAcquire().
T QAtomicInteger::fetchAndSubOrdered(T valueToSub)
Atomares Holen und Subtrahieren.
Liest den aktuellen Wert dieses QAtomicInteger und subtrahiert dann valueToSub vom aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine geordnete memory ordering Semantik, die sicherstellt, dass die Speicherzugriffe vor und nach der atomaren Operation (in der Programmreihenfolge) nicht neu geordnet werden können.
Siehe auch operator-=() und fetchAndAddOrdered().
T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)
Atomares Holen-und-Sub.
Liest den aktuellen Wert dieser QAtomicInteger und subtrahiert dann valueToSub vom aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe frei zu ordnen.
Siehe auch operator-=() und fetchAndAddRelaxed().
T QAtomicInteger::fetchAndSubRelease(T valueToSub)
Atomares Holen-und-Sub.
Liest den aktuellen Wert dieses QAtomicInteger und subtrahiert dann valueToSub vom aktuellen Wert und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik der Freigabe memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in der Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
Siehe auch operator-=() und fetchAndAddRelease().
T QAtomicInteger::fetchAndXorAcquire(T valueToXor)
Atomarer Abruf und XOR.
Liest den aktuellen Wert von QAtomicInteger und führt dann eine bitweise XOR-Verknüpfung von valueToXor mit dem aktuellen Wert durch und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der auf die atomare Operation folgende Speicherzugriff (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden darf.
Siehe auch operator^=().
T QAtomicInteger::fetchAndXorOrdered(T valueToXor)
Atomarer Abruf und XOR.
Liest den aktuellen Wert von QAtomicInteger und führt dann eine bitweise XOR-Verknüpfung von valueToXor mit dem aktuellen Wert durch und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in Programmreihenfolge) nicht neu geordnet werden kann.
Siehe auch operator^=().
T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)
Atomarer Abruf und XOR.
Liest den aktuellen Wert dieser QAtomicInteger und führt dann eine bitweise XOR-Verknüpfung von valueToXor mit dem aktuellen Wert durch und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe neu zu ordnen.
Siehe auch operator^=().
T QAtomicInteger::fetchAndXorRelease(T valueToXor)
Atomarer Abruf und XOR.
Liest den aktuellen Wert dieses QAtomicInteger und führt dann eine bitweise XOR-Verknüpfung von valueToXor mit dem aktuellen Wert durch und gibt den ursprünglichen Wert zurück.
Diese Funktion verwendet die Semantik von release memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
Siehe auch operator^=().
[static constexpr]
bool QAtomicInteger::isFetchAndAddNative()
Gibt true
zurück, wenn fetch-and-add mit atomaren Prozessorbefehlen implementiert ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isFetchAndAddWaitFree()
Gibt true
zurück, wenn atomic fetch-and-add wartungsfrei ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isFetchAndStoreNative()
Gibt true
zurück, wenn fetch-and-store mit atomaren Prozessorbefehlen implementiert ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isFetchAndStoreWaitFree()
Gibt true
zurück, wenn atomares Holen und Speichern wartungsfrei ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isReferenceCountingNative()
Gibt true
zurück, wenn die Referenzzählung mit atomaren Prozessoranweisungen implementiert ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isReferenceCountingWaitFree()
Gibt true
zurück, wenn die atomare Referenzzählung wartungsfrei ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isTestAndSetNative()
Gibt true
zurück, wenn test-and-set mit atomaren Prozessorbefehlen implementiert ist, andernfalls false.
[static constexpr]
bool QAtomicInteger::isTestAndSetWaitFree()
Gibt true
zurück, wenn atomic test-and-set wartungsfrei ist, andernfalls false.
T QAtomicInteger::loadAcquire() const
Lädt atomar den Wert dieser QAtomicInteger unter Verwendung der Speicherreihenfolge "Acquire". Der Wert wird in keiner Weise verändert, aber es gibt keine Garantie, dass er so bleibt.
Siehe auch storeRelaxed() und loadRelaxed().
T QAtomicInteger::loadRelaxed() const
Lädt atomar den Wert dieser QAtomicInteger unter Verwendung einer entspannten Speicheranordnung. Der Wert wird in keiner Weise verändert, aber es gibt keine Garantie, dass er so bleibt.
Siehe auch storeRelaxed() und loadAcquire().
bool QAtomicInteger::ref()
Erhöht atomar den Wert dieses QAtomicInteger. Gibt true
zurück, wenn der neue Wert ungleich Null ist, andernfalls false.
Diese Funktion verwendet die geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in der Programmreihenfolge) nicht neu geordnet werden kann.
Siehe auch deref() und operator++().
void QAtomicInteger::storeRelaxed(T newValue)
Speichert den Wert newValue atomar in diesem atomaren Typ, wobei eine entspannte Speicherordnung verwendet wird.
Siehe auch storeRelease() und loadRelaxed().
void QAtomicInteger::storeRelease(T newValue)
Speichert den Wert newValue in diesem atomaren Typ unter Verwendung der Speicheranordnung "Release".
Siehe auch storeRelaxed() und loadAcquire().
bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue)
Atomarer Test-und-Satz.
Hinweis: Wenn Sie diese Funktion in einer Schleife verwenden, sollten Sie stattdessen die Überladung mit dem zusätzlichen Argument T ¤tValue
verwenden, wodurch das zusätzliche load() im Fehlerfall vermieden wird.
Wenn der aktuelle Wert dieser QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen die newValue dieser QAtomicInteger zu und geben true zurück. Wenn die Werte nicht übereinstimmen, tut diese Funktion nichts und gibt false
zurück.
Diese Funktion verwendet die Semantik von acquire memory ordering, die sicherstellt, dass der Speicherzugriff nach der atomaren Operation (in der Reihenfolge des Programms) nicht vor der atomaren Operation neu geordnet werden kann.
bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue, T ¤tValue)
Atomares Testen und Setzen.
Wenn der aktuelle Wert dieses QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen den newValue diesem QAtomicInteger zu und geben true
zurück. Wenn die Werte nicht übereinstimmen, laden die Funktionen den aktuellen Wert dieser QAtomicInteger in currentValue und geben false
zurück.
Diese Funktion verwendet die Semantik "acquire memory ordering ", die sicherstellt, dass der Speicherzugriff nach der atomaren Operation (in Programmreihenfolge) nicht vor der atomaren Operation neu geordnet werden kann.
bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue)
Atomarer Test-und-Satz.
Hinweis: Wenn Sie diese Funktion in einer Schleife verwenden, sollten Sie stattdessen die Überladung mit dem zusätzlichen Argument T ¤tValue
verwenden, wodurch das zusätzliche load() im Fehlerfall vermieden wird.
Wenn der aktuelle Wert dieser QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen die newValue dieser QAtomicInteger zu und geben true zurück. Wenn die Werte nicht übereinstimmen, tut diese Funktion nichts und gibt false
zurück.
Diese Funktion verwendet eine geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in der Reihenfolge des Programms) nicht neu geordnet werden kann.
bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue, T ¤tValue)
Atomares Testen und Setzen.
Wenn der aktuelle Wert dieses QAtomicInteger der expectedValue ist, weisen die test-and-set Funktionen den newValue diesem QAtomicInteger zu und geben true
zurück. Wenn die Werte nicht übereinstimmen, wird der aktuelle Wert von QAtomicInteger in currentValue geladen und false
zurückgegeben.
Diese Funktion verwendet eine geordnete memory ordering Semantik, die sicherstellt, dass der Speicherzugriff vor und nach der atomaren Operation (in der Reihenfolge des Programms) nicht neu geordnet werden kann.
bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue)
Atomarer Test-und-Satz.
Hinweis: Wenn Sie diese Funktion in einer Schleife verwenden, sollten Sie stattdessen die Überladung mit dem zusätzlichen Argument T ¤tValue
verwenden, wodurch das zusätzliche load() im Fehlerfall vermieden wird.
Wenn der aktuelle Wert dieser QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen die newValue dieser QAtomicInteger zu und geben true zurück. Wenn die Werte nicht übereinstimmen, tut diese Funktion nichts und gibt false
zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe frei zu ordnen.
bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue, T ¤tValue)
Atomares Testen und Setzen.
Wenn der aktuelle Wert dieses QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen den newValue diesem QAtomicInteger zu und geben true
zurück. Wenn die Werte nicht übereinstimmen, laden die Funktionen den aktuellen Wert von QAtomicInteger in currentValue und geben false
zurück.
Diese Funktion verwendet eine entspannte memory ordering Semantik, die es dem Compiler und dem Prozessor überlässt, die Speicherzugriffe frei zu ordnen.
bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue)
Atomarer Test-und-Satz.
Hinweis: Wenn Sie diese Funktion in einer Schleife verwenden, sollten Sie stattdessen die Überladung mit dem zusätzlichen Argument T ¤tValue
verwenden, wodurch das zusätzliche load() im Fehlerfall vermieden wird.
Wenn der aktuelle Wert dieser QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen die newValue dieser QAtomicInteger zu und geben true zurück. Wenn die Werte nicht übereinstimmen, tut diese Funktion nichts und gibt false
zurück.
Diese Funktion verwendet die Semantik der Freigabe memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in der Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden kann.
bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue, T ¤tValue)
Atomares Testen und Setzen.
Wenn der aktuelle Wert dieses QAtomicInteger der expectedValue ist, weisen die test-and-set-Funktionen den newValue diesem QAtomicInteger zu und geben true
zurück. Wenn die Werte nicht übereinstimmen, laden die Funktionen den aktuellen Wert dieser QAtomicInteger in currentValue und geben false
zurück.
Diese Funktion verwendet die Semantik der Freigabe memory ordering, die sicherstellt, dass der Speicherzugriff vor der atomaren Operation (in der Programmreihenfolge) nach der atomaren Operation nicht neu geordnet werden darf.
T QAtomicInteger::operator T() const
Atomares Laden des Wertes dieser QAtomicInteger unter Verwendung einer sequentiell konsistenten Speicheranordnung, wenn möglich; oder "Acquire"-Reihenfolge, wenn nicht. Der Wert wird in keiner Weise verändert, aber es gibt keine Garantie, dass er so bleibt.
Siehe auch loadRelaxed() und loadAcquire().
T QAtomicInteger::operator&=(T value)
Atomares Hinzufügen und Abrufen.
Liest den aktuellen Wert dieser QAtomicInteger und verknüpft dann value bitweise mit dem aktuellen Wert und gibt den neuen Wert zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, wenn möglich; oder "geordnete" Anordnung, wenn nicht.
Siehe auch fetchAndAndOrdered().
T QAtomicInteger::operator++()
Erhöht den Wert dieses QAtomicInteger atomar vor. Gibt den neuen Wert dieses Atoms zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, falls möglich; oder "Geordnete" Anordnung, falls nicht.
Siehe auch ref(), operator++(int), und operator--().
T QAtomicInteger::operator++(int)
Erhöht den Wert dieses QAtomicInteger atomar nach. Gibt den alten Wert dieses Atoms zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicherordnung, falls möglich; oder eine "geordnete" Ordnung, falls nicht.
Siehe auch ref(), operator++(), und operator--(int).
T QAtomicInteger::operator+=(T value)
Atomares Hinzufügen und Abrufen.
Liest den aktuellen Wert dieser QAtomicInteger und addiert dann value zum aktuellen Wert und gibt den neuen Wert zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, wenn möglich; oder eine "geordnete" Anordnung, wenn nicht.
Siehe auch fetchAndAddOrdered() und operator-=().
T QAtomicInteger::operator--()
Verringert den Wert dieses QAtomicInteger atomar vor. Gibt den neuen Wert dieses Atoms zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicherordnung, falls möglich; oder eine "geordnete" Ordnung, falls nicht.
Siehe auch deref(), operator--(int), und operator++().
T QAtomicInteger::operator--(int)
Verringert den Wert dieses QAtomicInteger atomar nach unten. Gibt den alten Wert dieses Atoms zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicherordnung, falls möglich; oder eine "geordnete" Ordnung, falls nicht.
Siehe auch deref(), operator--(), und operator++(int).
T QAtomicInteger::operator-=(T value)
Atomares Sub-and-Fetch.
Liest den aktuellen Wert von QAtomicInteger, subtrahiert dann value vom aktuellen Wert und gibt den neuen Wert zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, wenn möglich; oder "Geordnete" Anordnung, wenn nicht.
Siehe auch fetchAndSubOrdered() und operator+=().
QAtomicInteger<T> &QAtomicInteger::operator=(T)
Speichert den anderen Wert atomar in diesem atomaren Typ unter Verwendung einer sequentiell konsistenten Speicheranordnung, wenn möglich; oder "Release"-Anordnung, wenn nicht. Diese Funktion gibt einen Verweis auf dieses Objekt zurück.
Siehe auch storeRelaxed() und storeRelease().
[noexcept]
QAtomicInteger<T> &QAtomicInteger::operator=(const QAtomicInteger<T> &other)
Weist other dieser QAtomicInteger zu und gibt einen Verweis auf diese QAtomicInteger zurück.
T QAtomicInteger::operator^=(T value)
Atomares xor-and-fetch.
Liest den aktuellen Wert dieser QAtomicInteger und führt dann eine bitweise XOR-Verknüpfung zwischen value und dem aktuellen Wert durch und gibt den neuen Wert zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, wenn möglich; oder "Geordnete" Anordnung, wenn nicht.
Siehe auch fetchAndXorOrdered().
T QAtomicInteger::operator|=(T value)
Atomarer Oder-Abruf.
Liest den aktuellen Wert dieser QAtomicInteger und führt dann eine bitweise ODER-Verknüpfung von value mit dem aktuellen Wert durch und gibt den neuen Wert zurück.
Diese Funktion verwendet eine sequentiell konsistente Speicheranordnung, wenn möglich; oder "Geordnete" Anordnung, wenn nicht.
Siehe auch fetchAndOrOrdered().
Verwandte Nicht-Mitglieder
[noexcept, since 6.7]
void qYieldCpu()
Unterbricht die Ausführung des aktuellen Threads für eine unbestimmte Zeit unter Verwendung von Hardwareanweisungen, ohne diesen Thread aus dem Zeitplan zu nehmen. Diese Funktion ist für Schleifen mit hohem Durchsatz gedacht, bei denen der Code erwartet, dass ein anderer Thread eine atomare Variable ändert. Sie unterscheidet sich vollständig von QThread::yieldCurrentThread(), einer Operation auf Betriebssystemebene, die den gesamten Thread von der CPU abziehen und die Ausführung anderer Threads (die möglicherweise zu anderen Prozessen gehören) ermöglichen kann.
Anstelle von
while (!condition) ;
sollte man schreiben
while (!condition) qYieldCpu();
Dies ist sowohl mit als auch ohne Hardware-Multithreading auf demselben Kern nützlich. Im Falle von Hardware-Threads wird damit verhindert, dass weitere spekulative Ausführungen die Pipeline füllen, wodurch der Geschwister-Thread Ressourcen verlieren könnte. Über Kerne und höhere Trennungsebenen hinweg ermöglicht es dem Cache-Kohärenzprotokoll, die geänderte und überprüfte Cache-Zeile dem logischen Prozessor zuzuweisen, dessen Ergebnis dieser Code erwartet.
Es wird auch empfohlen, eine Schleife um Code zu legen, der die globale Variable nicht verändert, um Konflikte bei der ausschließlichen Beschaffung des Speicherplatzes zu vermeiden. Daher sollte eine atomare Änderungsschleife, wie z. B. eine Spinlock-Erfassung, verwendet werden:
while (true) { while (!readOnlyCondition(atomic)) qYieldCpu(); if (modify(atomic)) break; }
Auf x86-Prozessoren und auf RISC-V-Prozessoren mit der Zihintpause
-Erweiterung wird die Anweisung PAUSE
ausgegeben, die auf Prozessoren, die dies nicht unterstützen, ignoriert wird; auf ARMv7- oder späteren ARM-Prozessoren wird die Anweisung YIELD
ausgegeben.
Diese Funktion wurde in Qt 6.7 eingeführt.
Makro-Dokumentation
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_ALWAYS_NATIVE
Dieses Makro ist nur dann definiert, wenn Ihr Prozessor das atomare Holen und Hinzufügen von Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_NOT_NATIVE
Dieses Makro wird definiert, wenn die Hardware kein atomares Fetch-and-Add auf Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
Dieses Makro wird definiert, wenn nur bestimmte Generationen des Prozessors atomares Holen und Hinzufügen bei ganzen Zahlen unterstützen. Verwenden Sie die Funktion QAtomicInteger<T>::isFetchAndAddNative(), um zu prüfen, was Ihr Prozessor unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_WAIT_FREE
Dieses Makro wird zusammen mit Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_ALWAYS_NATIVE definiert, um anzuzeigen, dass das atomare Holen und Hinzufügen auf Ganzzahlen wartungsfrei ist.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE
Dieses Makro ist nur dann definiert, wenn Ihr Prozessor atomares Holen und Speichern auf Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_NOT_NATIVE
Dieses Makro wird definiert, wenn die Hardware kein atomares Holen und Speichern auf Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
Dieses Makro wird definiert, wenn nur bestimmte Generationen des Prozessors atomares Holen und Speichern auf Ganzzahlen unterstützen. Verwenden Sie die Funktion QAtomicInteger<T>::isFetchAndStoreNative(), um zu prüfen, was Ihr Prozessor unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_WAIT_FREE
Dieses Makro wird zusammen mit Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE definiert, um anzuzeigen, dass das atomare Holen und Speichern auf Ganzzahlen wartungsfrei ist.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_IS_SUPPORTED
Dieses Makro ist definiert, wenn atomare Ganzzahlen der Größe nn (in Bits) in dieser Compiler/Architektur-Kombination unterstützt werden.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Die folgenden Makros sind immer definiert:
- Q_ATOMIC_INT8_IST_UNTERSTÜTZT
- Q_ATOMIC_INT16_IST_UNTERSTÜTZT
- Q_ATOMIC_INT32_IST_UNTERSTÜTZT
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
Dieses Makro ist nur dann definiert, wenn alle Generationen Ihres Prozessors die atomare Referenzzählung unterstützen.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_NOT_NATIVE
Dieses Makro wird definiert, wenn die Hardware keine atomare Referenzzählung unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE
Dieses Makro wird definiert, wenn nur bestimmte Generationen des Prozessors die atomare Referenzzählung unterstützen. Verwenden Sie die Funktion QAtomicInteger<T>::isReferenceCountingNative(), um zu prüfen, was Ihr Prozessor unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_WAIT_FREE
Dieses Makro wird zusammen mit Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_ALWAYS_NATIVE definiert, um anzuzeigen, dass die Referenzzählung wartungsfrei ist.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_ALWAYS_NATIVE
Dieses Makro ist nur dann definiert, wenn Ihr Prozessor atomares Testen und Setzen auf Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_NOT_NATIVE
Dieses Makro wird definiert, wenn die Hardware kein atomares Testen und Setzen auf Ganzzahlen unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_SOMETIMES_NATIVE
Dieses Makro wird definiert, wenn nur bestimmte Generationen des Prozessors atomares Testen und Setzen auf Ganzzahlen unterstützen. Verwenden Sie die Funktion QAtomicInteger<T>::isTestAndSetNative(), um zu prüfen, was Ihr Prozessor unterstützt.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_WAIT_FREE
Dieses Makro ist zusammen mit Q_ATOMIC_INTnn_TEST_AND_SET_IS_ALWAYS_NATIVE definiert, um anzuzeigen, dass das atomare Testen und Setzen auf Ganzzahlen wartungsfrei ist.
nn ist die Größe der Ganzzahl in Bits (8, 16, 32 oder 64).
© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.