The QAtomicInt class provides platform-independent atomic operations on integers.
For atomic operations on pointers, see the QAtomicPointer class.
An complex operation that completes without interruption is said to be atomic. The QAtomicInt class provides atomic reference counting, test-and-set, fetch-and-store, and fetch-and-add for integers.
Non-atomic convenience operators
For convenience, QAtomicInt provides integer comparison, cast, and assignment operators. Note that a combination of these operators is not an atomic operation.
The Atomic API
Reference counting
The ref() and deref() functions provide an efficient reference counting API. The return value of these functions are used to indicate when the last reference has been released. These functions allow you to implement your own implicitly shared classes.
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;
}
Memory ordering
QAtomicInt provides several implementations of the atomic test-and-set, fetch-and-store, and fetch-and-add functions. Each implementation defines a memory ordering semantic that describes how memory accesses surrounding the atomic instruction are executed by the processor. Since many modern architectures allow out-of-order execution and memory ordering, using the correct semantic is necessary to ensure that your application functions properly on all processors.
Relaxed - memory ordering is unspecified, leaving the compiler and processor to freely reorder memory accesses.
Acquire - memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.
Release - memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.
Ordered - the same Acquire and Release semantics combined.
Test-and-set
If the current value of the QAtomicInt is an expected value, the test-and-set functions assign a new value to the QAtomicInt and return true. If values are not the same, these functions do nothing and return false. This operation equates to the following code:
The atomic fetch-and-store functions read the current value of the QAtomicInt and then assign a new value, returning the original value. This operation equates to the following code:
int originalValue = currentValue;
currentValue = newValue;
return originalValue;
The atomic fetch-and-add functions read the current value of the QAtomicInt and then add the given value to the current value, returning the original value. This operation equates to the following code:
int originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;
Providing a platform-independent atomic API that works on all processors is challenging. The API provided by QAtomicInt is guaranteed to work atomically on all processors. However, since not all processors implement support for every operation provided by QAtomicInt, it is necessary to expose information about the processor.
An operation that completes in constant time is said to be wait-free. Such operations are not implemented using locks or loops of any kind. For atomic operations that are always supported, and that are wait-free, Qt defines the Q_ATOMIC_INT_OPERATION_IS_WAIT_FREE in addition to the Q_ATOMIC_INT_OPERATION_IS_ALWAYS_NATIVE.
QAtomicInt::QAtomicInt ( const QAtomicInt & other )
Constructs a copy of other.
bool QAtomicInt::deref ()
Atomically decrements the value of this QAtomicInt. Returns true if the new value is non-zero, false otherwise.
This function uses orderedmemory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.
int QAtomicInt::fetchAndAddAcquire ( int valueToAdd )
Atomic fetch-and-add.
Reads the current value of this QAtomicInt and then adds valueToAdd to the current value, returning the original value.
This function uses acquirememory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.
int QAtomicInt::fetchAndAddOrdered ( int valueToAdd )
Atomic fetch-and-add.
Reads the current value of this QAtomicInt and then adds valueToAdd to the current value, returning the original value.
This function uses orderedmemory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.
int QAtomicInt::fetchAndAddRelaxed ( int valueToAdd )
Atomic fetch-and-add.
Reads the current value of this QAtomicInt and then adds valueToAdd to the current value, returning the original value.
This function uses relaxedmemory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.
int QAtomicInt::fetchAndAddRelease ( int valueToAdd )
Atomic fetch-and-add.
Reads the current value of this QAtomicInt and then adds valueToAdd to the current value, returning the original value.
This function uses releasememory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.
int QAtomicInt::fetchAndStoreAcquire ( int newValue )
Atomic fetch-and-store.
Reads the current value of this QAtomicInt and then assigns it the newValue, returning the original value.
This function uses acquirememory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.
int QAtomicInt::fetchAndStoreOrdered ( int newValue )
Atomic fetch-and-store.
Reads the current value of this QAtomicInt and then assigns it the newValue, returning the original value.
This function uses orderedmemory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.
int QAtomicInt::fetchAndStoreRelaxed ( int newValue )
Atomic fetch-and-store.
Reads the current value of this QAtomicInt and then assigns it the newValue, returning the original value.
This function uses relaxedmemory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.
int QAtomicInt::fetchAndStoreRelease ( int newValue )
Atomic fetch-and-store.
Reads the current value of this QAtomicInt and then assigns it the newValue, returning the original value.
This function uses releasememory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.
bool QAtomicInt::isFetchAndAddNative () [static]
Returns true if fetch-and-add is implemented using atomic processor instructions, false otherwise.
Returns true if atomic reference counting is wait-free, false otherwise.
bool QAtomicInt::isTestAndSetNative () [static]
Returns true if test-and-set is implemented using atomic processor instructions, false otherwise.
bool QAtomicInt::isTestAndSetWaitFree () [static]
Returns true if atomic test-and-set is wait-free, false otherwise.
bool QAtomicInt::ref ()
Atomically increments the value of this QAtomicInt. Returns true if the new value is non-zero, false otherwise.
This function uses orderedmemory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.
bool QAtomicInt::testAndSetAcquire ( int expectedValue, int newValue )
Atomic test-and-set.
If the current value of this QAtomicInt is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInt and return true. If the values are not the same, this function does nothing and returns false.
This function uses acquirememory ordering semantics, which ensures that memory access following the atomic operation (in program order) may not be re-ordered before the atomic operation.
bool QAtomicInt::testAndSetOrdered ( int expectedValue, int newValue )
Atomic test-and-set.
If the current value of this QAtomicInt is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInt and return true. If the values are not the same, this function does nothing and returns false.
This function uses orderedmemory ordering semantics, which ensures that memory access before and after the atomic operation (in program order) may not be re-ordered.
bool QAtomicInt::testAndSetRelaxed ( int expectedValue, int newValue )
Atomic test-and-set.
If the current value of this QAtomicInt is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInt and return true. If the values are not the same, this function does nothing and returns false.
This function uses relaxedmemory ordering semantics, leaving the compiler and processor to freely reorder memory accesses.
bool QAtomicInt::testAndSetRelease ( int expectedValue, int newValue )
Atomic test-and-set.
If the current value of this QAtomicInt is the expectedValue, the test-and-set functions assign the newValue to this QAtomicInt and return true. If the values are not the same, this function does nothing and returns false.
This function uses releasememory ordering semantics, which ensures that memory access before the atomic operation (in program order) may not be re-ordered after the atomic operation.
QAtomicInt::operator int () const
Returns the value stored by the QAtomicInt object as an integer.
bool QAtomicInt::operator! () const
Returns true is the value of this QAtomicInt is zero; otherwise returns false.
bool QAtomicInt::operator!= ( int value ) const
Returns true if the value of this QAtomicInt is not equal to value; otherwise returns false.
QAtomicInt & QAtomicInt::operator= ( int value )
Assigns the value to this QAtomicInt and returns a reference to this QAtomicInt.
QAtomicInt & QAtomicInt::operator= ( const QAtomicInt & other )
Returns true if the value is equal to the value in this QAtomicInt; otherwise returns false.
Macro Documentation
Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE
This macro is defined if and only if your processor supports atomic fetch-and-add on integers.
Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE
This macro is defined when the hardware does not support atomic fetch-and-add on integers.
Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
This macro is defined when only certain generations of the processor support atomic fetch-and-add on integers. Use the QAtomicInt::isFetchAndAddNative() function to check what your processor supports.
This macro is defined if and only if your processor supports atomic fetch-and-store on integers.
Q_ATOMIC_INT_FETCH_AND_STORE_IS_NOT_NATIVE
This macro is defined when the hardware does not support atomic fetch-and-store on integers.
Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
This macro is defined when only certain generations of the processor support atomic fetch-and-store on integers. Use the QAtomicInt::isFetchAndStoreNative() function to check what your processor supports.
This macro is defined when only certain generations of the processor support atomic reference counting. Use the QAtomicInt::isReferenceCountingNative() function to check what your processor supports.
This macro is defined if and only if your processor supports atomic test-and-set on integers.
Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE
This macro is defined when the hardware does not support atomic test-and-set on integers.
Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE
This macro is defined when only certain generations of the processor support atomic test-and-set on integers. Use the QAtomicInt::isTestAndSetNative() function to check what your processor supports.
Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).
Qt dans le magazine
Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia.
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter
ou par MP !
