QAtomicInteger Class
template <typename T> class QAtomicIntegerLa clase `QAtomicInteger` permite realizar operaciones atómicas con números enteros, independientes de la plataforma. Más información...
| Encabezado: | #include <QAtomicInteger> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado por: |
- Lista de todos los miembros, incluidos los heredados
- QAtomicInteger forma parte de las clases de subprocesos.
Funciones públicas
| 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) |
| 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) |
Miembros públicos estáticos
| bool | isFetchAndAddNative() |
| bool | isFetchAndAddWaitFree() |
| bool | isFetchAndStoreNative() |
| bool | isFetchAndStoreWaitFree() |
| bool | isReferenceCountingNative() |
| bool | isReferenceCountingWaitFree() |
| bool | isTestAndSetNative() |
| bool | isTestAndSetWaitFree() |
Elementos no miembros relacionados
(since 6.7) void | qYieldCpu() |
Macros
Descripción detallada
Para operaciones atómicas con punteros, consulta la clase ` QAtomicPointer `.
Una operación atómica es una operación compleja que se completa sin interrupciones. La clase QAtomicInteger proporciona recuento de referencias atómico, «test-and-set», «fetch-and-store» y «fetch-and-add» para enteros. El parámetro de plantilla T especifica el tipo entero que se va a convertir en atómico.
El parámetro de plantilla T debe ser un tipo entero de C++:
- 8 bits: bool, char, signed char, unsigned char, qint8, quint8, char8_t (C++20)
- 16 bits: short, unsigned short, qint16, quint16, char16_t
- 32 bits: int, unsigned int, qint32, quint32, char32_t
- 64 bits: long long, unsigned long long, qint64, quint64
- tamaño específico de la plataforma: long, unsigned long
- tamaño de puntero: qintptr, quintptr, qptrdiff
De la lista anterior, solo se garantiza que las instancias de 8 bits, 16 bits, 32 bits y del tamaño de un puntero funcionen en todas las plataformas. La compatibilidad con otros tamaños depende del compilador y de la arquitectura del procesador para el que se compile el código. Para comprobar si los tipos de 64 bits son compatibles con plataformas de 32 bits, consulta la macro ` Q_ATOMIC_INT64_IS_SUPPORTED`.
La API atómica
Recuento de referencias
Las funciones ` ref()` y ` deref()` proporcionan una API eficiente de recuento de referencias. El valor de retorno de estas funciones se utiliza para indicar cuándo se ha liberado la última referencia. Estas funciones te permiten implementar tus propias clases compartidas implícitamente.
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;
}Orden de la memoria
QAtomicInteger proporciona varias implementaciones de las funciones atómicas «test-and-set», «fetch-and-store» y «fetch-and-add». Cada implementación define una semántica de ordenación de la memoria que describe cómo el procesador ejecuta los accesos a la memoria que rodean a la instrucción atómica. Dado que muchas arquitecturas modernas permiten la ejecución fuera de orden y la ordenación de la memoria, es necesario utilizar la semántica correcta para garantizar que la aplicación funcione correctamente en todos los procesadores.
- Relajada: el orden de la memoria no está especificado, lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
- «Acquire»: los accesos a la memoria que siguen a la operación atómica (en el orden del programa) no pueden reordenarse antes de la operación atómica.
- Release: los accesos a la memoria anteriores a la operación atómica (en el orden del programa) no pueden reordenarse después de la operación atómica.
- Ordenado: combina las semánticas de «Adquirir» y «Liberar».
Prueba y establecimiento
Si el valor actual de QAtomicInteger es el valor esperado, las funciones «test-and-set» asignan un nuevo valor a QAtomicInteger y devuelven «true». Si los valores no coinciden, estas funciones no realizan ninguna acción y devuelven «false». Esta operación equivale al siguiente código:
if (currentValue == expectedValue) {
currentValue = newValue;
return true;
}
return false;Hay cuatro funciones «test-and-set»: ` testAndSetRelaxed()`, ` testAndSetAcquire()`, ` testAndSetRelease()` y ` testAndSetOrdered()`. Véase más arriba la explicación de las diferentes semánticas de ordenación de la memoria.
Fetch-and-store
Las funciones atómicas de lectura y escritura leen el valor actual del QAtomicInteger y, a continuación, le asignan un nuevo valor, devolviendo el valor original. Esta operación equivale al siguiente código:
int originalValue = currentValue;
currentValue = newValue;
return originalValue;Hay cuatro funciones de lectura y almacenamiento: fetchAndStoreRelaxed(), fetchAndStoreAcquire(), fetchAndStoreRelease() y fetchAndStoreOrdered(). Véase más arriba la explicación de las diferentes semánticas de ordenación de la memoria.
Lectura y suma
Las funciones atómicas de lectura y suma leen el valor actual del QAtomicInteger y, a continuación, suman el valor dado al valor actual, devolviendo el valor original. Esta operación equivale al siguiente código:
int originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;Hay cuatro funciones de lectura y suma: fetchAndAddRelaxed(), fetchAndAddAcquire(), fetchAndAddRelease() y fetchAndAddOrdered(). Véase más arriba una explicación de las diferentes semánticas de ordenación de memoria.
Pruebas de funcionalidad para la API atómica
Ofrecer una API atómica independiente de la plataforma que funcione en todos los procesadores supone un reto. Se garantiza que la API proporcionada por `QAtomicInteger` funciona de forma atómica en todos los procesadores. Sin embargo, dado que no todos los procesadores implementan soporte para todas las operaciones que ofrece `QAtomicInteger`, es necesario exponer información sobre el procesador.
Puedes comprobar en tiempo de compilación qué características son compatibles con tu hardware utilizando diversas macros. Estas te indicarán si tu hardware admite una operación concreta siempre, a veces o en ningún caso. Las macros tienen la formaQ_ATOMIC_INTnn_OPERATION_IS_HOW_NATIVE. nn es el tamaño del entero (en bits), OPERATION es una de las siguientes: REFERENCE_COUNTING, TEST_AND_SET, FETCH_AND_STORE o FETCH_AND_ADD, y HOW es una de las siguientes: ALWAYS, SOMETIMES o NOT. Siempre habrá exactamente una macro definida por operación. Por ejemplo, si se define Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_ALWAYS_NATIVE, no se definirán ni Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE ni Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_NOT_NATIVE.
Se dice que una operación que se completa en tiempo constante es «sin espera». Dichas operaciones no se implementan utilizando bloqueos ni bucles de ningún tipo. Para las operaciones atómicas que siempre son compatibles y que no implican espera, Qt defineQ_ATOMIC_INTnn_OPERATION_IS_WAIT_FREE además deQ_ATOMIC_INTnn_OPERATION_IS_ALWAYS_NATIVE.
En los casos en que una operación atómica solo sea compatible con las generaciones más recientes del procesador, QAtomicInteger también ofrece una forma de comprobar en tiempo de ejecución qué es lo que admite el hardware mediante las funciones ` isReferenceCountingNative()`, ` isTestAndSetNative()`, ` isFetchAndStoreNative()` y ` isFetchAndAddNative()`. Las implementaciones «sin espera» pueden detectarse mediante las funciones ` isReferenceCountingWaitFree()`, ` isTestAndSetWaitFree()`, ` isFetchAndStoreWaitFree()` y ` isFetchAndAddWaitFree()`.
A continuación se muestra una lista completa de todas las macros de características para 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_ES_SIEMPRE_NATIVO
- Q_ATOMIC_INTnn_TEST_AND_SET_ES_A_VECES_NATIVO
- Q_ATOMIC_INTnn_TEST_AND_SET_NO_ES_NATIVO
- Q_ATOMIC_INTnn_TEST_AND_SET_IS_SIN ESPERA
- Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_STORE_ES_A VECES_NATIVO
- 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_ES_A_VECES_NATIVO
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_NOT_NATIVE
- Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_WAIT_FREE
Para garantizar la compatibilidad con versiones anteriores de Qt, las macros con un nn vacío son equivalentes a las macros de 32 bits. Por ejemplo, Q_ATOMIC_INT_REFERENCE_COUNTING_IS_WAIT_FREE es lo mismo que Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_WAIT_FREE.
Véase también QAtomicPointer.
Documentación de funciones miembro
[constexpr noexcept] QAtomicInteger::QAtomicInteger(T value = 0)
Crea un objeto `QAtomicInteger` con el valor ` value` proporcionado.
[noexcept] QAtomicInteger::QAtomicInteger(const QAtomicInteger<T> &other)
Crea una copia de other.
bool QAtomicInteger::deref()
Decrementa de forma atómica el valor de este QAtomicInteger. Devuelve true si el nuevo valor es distinto de cero; en caso contrario, devuelve false.
Esta función utiliza la semántica ordenada de ` memory ordering `, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véanse también ref() y operator--().
T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)
Operación atómica de lectura y suma.
Lee el valor actual de este QAtomicInteger y, a continuación, suma valueToAdd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica «adquirir- memory ordering », que garantiza que el acceso a la memoria posterior a la operación atómica (en el orden del programa) no pueda reordenarse antes de la operación atómica.
Véanse también operator+=() y fetchAndSubAcquire().
T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)
Operación atómica de lectura y suma.
Lee el valor actual de este QAtomicInteger y, a continuación, suma valueToAdd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica de « memory ordering » ordenada, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véase también ` operator+=()` y ` fetchAndSubOrdered()`.
T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)
Operación atómica de lectura y suma.
Lee el valor actual de este QAtomicInteger y, a continuación, suma valueToAdd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
Véanse también « operator+=()» y « fetchAndSubRelaxed()».
T QAtomicInteger::fetchAndAddRelease(T valueToAdd)
Operación atómica de lectura y suma.
Lee el valor actual de este QAtomicInteger y, a continuación, suma valueToAdd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse tras la operación atómica.
Véanse también operator+=() y fetchAndSubRelease().
T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)
Operación atómica «fetch-and-and».
Lee el valor actual de este « QAtomicInteger » y, a continuación, aplica una operación AND bit a bit a valueToAnd sobre el valor actual, devolviendo el valor original.
Esta función utiliza la semántica «acquire- memory ordering », que garantiza que los accesos a la memoria que siguen a la operación atómica (en el orden del programa) no puedan reordenarse antes de dicha operación.
Véase también ` operator&=()`.
T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)
Operación atómica «fetch-and-and».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica un AND bit a bit valueToAnd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica de « memory ordering » ordenado, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véase también ` operator&=()`.
T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)
Operación atómica «fetch-and-and».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación AND bit a bit a valueToAnd sobre el valor actual, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
Véase también ` operator&=()`.
T QAtomicInteger::fetchAndAndRelease(T valueToAnd)
Operación atómica «fetch-and-and».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación AND bit a bit valueToAnd al valor actual, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que los accesos a la memoria anteriores a la operación atómica (en el orden del programa) no puedan reordenarse después de la operación atómica.
Véase también ` operator&=()`.
T QAtomicInteger::fetchAndOrAcquire(T valueToOr)
Operación atómica «fetch-and-or».
Lee el valor actual de este QAtomicInteger y, a continuación, realiza una operación OR bit a bit c valueToOr o con el valor actual, devolviendo el valor original.
Esta función utiliza la semántica «adquirir- memory ordering », que garantiza que el acceso a la memoria posterior a la operación atómica (en el orden del programa) no pueda reordenarse antes de la operación atómica.
Véase también operator|=().
T QAtomicInteger::fetchAndOrOrdered(T valueToOr)
Operación atómica «fetch-and-or».
Lee el valor actual de este « QAtomicInteger » y, a continuación, realiza una operación OR bit a bit entre « valueToOr » y el valor actual, devolviendo el valor original.
Esta función utiliza la semántica « memory ordering » ordenada, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véase también ` operator|=()`.
T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)
Operación atómica «fetch-and-or».
Lee el valor actual de este « QAtomicInteger » y, a continuación, realiza una operación OR bit a bit entre « valueToOr » y el valor actual, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
Véase también ` operator|=()`.
T QAtomicInteger::fetchAndOrRelease(T valueToOr)
Operación atómica «fetch-and-or».
Lee el valor actual de este QAtomicInteger y, a continuación, realiza una operación OR bit a bit entre valueToOr y el valor actual, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica.
Véase también ` operator|=()`.
T QAtomicInteger::fetchAndStoreAcquire(T newValue)
Operación atómica de lectura y escritura.
Lee el valor actual de este QAtomicInteger y, a continuación, le asigna el newValue, devolviendo el valor original.
Esta función utiliza la semántica «adquirir- memory ordering », que garantiza que los accesos a la memoria que siguen a la operación atómica (en el orden del programa) no puedan reordenarse antes de dicha operación.
T QAtomicInteger::fetchAndStoreOrdered(T newValue)
Operación atómica de lectura y escritura.
Lee el valor actual de este QAtomicInteger y, a continuación, le asigna el newValue, devolviendo el valor original.
Esta función utiliza la semántica de « memory ordering » ordenada, lo que garantiza que los accesos a la memoria anteriores y posteriores a la operación atómica (en el orden del programa) no puedan reordenarse.
T QAtomicInteger::fetchAndStoreRelaxed(T newValue)
Operación atómica de lectura y escritura.
Lee el valor actual de este QAtomicInteger y, a continuación, le asigna el newValue, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
T QAtomicInteger::fetchAndStoreRelease(T newValue)
Operación atómica de lectura y escritura.
Lee el valor actual de este QAtomicInteger y, a continuación, le asigna el newValue, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica.
T QAtomicInteger::fetchAndSubAcquire(T valueToSub)
Operación atómica de lectura y sustitución.
Lee el valor actual de este QAtomicInteger y, a continuación, resta valueToSub del valor actual, devolviendo el valor original.
Esta función utiliza la semántica «acquire- memory ordering », que garantiza que los accesos a la memoria que siguen a la operación atómica (en el orden del programa) no puedan reordenarse antes de dicha operación.
Véanse también « operator-=()» y « fetchAndAddAcquire()».
T QAtomicInteger::fetchAndSubOrdered(T valueToSub)
Operación atómica de lectura y sustitución.
Lee el valor actual de este « QAtomicInteger » y, a continuación, resta « valueToSub » del valor actual, devolviendo el valor original.
Esta función utiliza la semántica de « memory ordering » ordenada, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véanse también operator-=() y fetchAndAddOrdered().
T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)
Operación atómica de lectura y sustitución.
Lee el valor actual de este « QAtomicInteger » y, a continuación, resta « valueToSub » del valor actual, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
Véase también « operator-=()» y « fetchAndAddRelaxed()».
T QAtomicInteger::fetchAndSubRelease(T valueToSub)
Operación atómica de lectura y sustitución.
Lee el valor actual de este QAtomicInteger y, a continuación, resta valueToSub del valor actual, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica.
Véanse también operator-=() y fetchAndAddRelease().
T QAtomicInteger::fetchAndXorAcquire(T valueToXor)
Operación atómica «fetch-and-xor».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación XOR bit a bit valueToXor al valor actual, devolviendo el valor original.
Esta función utiliza la semántica «acquire- memory ordering », que garantiza que los accesos a la memoria que siguen a la operación atómica (en el orden del programa) no puedan reordenarse antes de dicha operación.
Véase también operator^=().
T QAtomicInteger::fetchAndXorOrdered(T valueToXor)
Operación atómica «fetch-and-xor».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación XOR bit a bit valueToXor al valor actual, devolviendo el valor original.
Esta función utiliza la semántica de « memory ordering » ordenado, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véase también ` operator^=()`.
T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)
Operación atómica «fetch-and-XOR».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación XOR bit a bit valueToXor al valor actual, devolviendo el valor original.
Esta función utiliza la semántica relajada de « memory ordering », lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
Véase también ` operator^=()`.
T QAtomicInteger::fetchAndXorRelease(T valueToXor)
Operación atómica «fetch-and-xor».
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación XOR bit a bit valueToXor al valor actual, devolviendo el valor original.
Esta función utiliza la semántica «release- memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica.
Véase también ` operator^=()`.
[static constexpr] bool QAtomicInteger::isFetchAndAddNative()
Devuelve « true » si «fetch-and-add» se implementa mediante instrucciones atómicas del procesador; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isFetchAndAddWaitFree()
Devuelve « true » si la operación «fetch-and-add» atómica es «wait-free»; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isFetchAndStoreNative()
Devuelve « true » si «fetch-and-store» se implementa mediante instrucciones atómicas del procesador; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isFetchAndStoreWaitFree()
Devuelve « true » si la operación atómica de lectura y escritura es «wait-free»; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isReferenceCountingNative()
Devuelve « true » si el recuento de referencias se implementa mediante instrucciones atómicas del procesador; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isReferenceCountingWaitFree()
Devuelve « true » si el recuento atómico de referencias no implica esperas; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isTestAndSetNative()
Devuelve « true » si «test-and-set» se implementa mediante instrucciones atómicas del procesador; en caso contrario, devuelve «false».
[static constexpr] bool QAtomicInteger::isTestAndSetWaitFree()
Devuelve ` true ` si la operación «test-and-set» atómica no requiere espera; en caso contrario, devuelve `false`.
T QAtomicInteger::loadAcquire() const
Carga de forma atómica el valor de este QAtomicInteger utilizando el orden de memoria «Acquire». El valor no se modifica en absoluto, pero ten en cuenta que no hay garantía de que siga siendo así.
Véase también storeRelaxed() y loadRelaxed().
T QAtomicInteger::loadRelaxed() const
Carga de forma atómica el valor de este ` QAtomicInteger ` utilizando un orden de memoria relajado. El valor no se modifica en absoluto, pero ten en cuenta que no hay garantía de que siga siendo así.
Véase también storeRelaxed() y loadAcquire().
bool QAtomicInteger::ref()
Incrementa de forma atómica el valor de este QAtomicInteger. Devuelve true si el nuevo valor es distinto de cero; en caso contrario, devuelve false.
Esta función utiliza la semántica ordenada de ` memory ordering `, lo que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
Véanse también deref() y operator++().
void QAtomicInteger::storeRelaxed(T newValue)
Almacena de forma atómica el valor de « newValue » en este tipo atómico, utilizando un orden de memoria relajado.
Véanse también « storeRelease()» y « loadRelaxed()».
void QAtomicInteger::storeRelease(T newValue)
Almacena de forma atómica el valor de « newValue » en este tipo atómico, utilizando el orden de memoria «Release».
Véase también storeRelaxed() y loadAcquire().
bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue)
Prueba y establecimiento atómicos.
Nota: Si utilizas esta función en un bucle, plantéate utilizar en su lugar la sobrecarga con el argumento adicional ` T ¤tValue `, lo que evita la llamada adicional a ` loadAcquire()` en caso de fallo.
Si el valor actual de este ` QAtomicInteger ` es el ` expectedValue`, las funciones de comprobación y asignación asignan el ` newValue ` a este ` QAtomicInteger ` y devuelven `true`. Si los valores no coinciden, esta función no realiza ninguna acción y devuelve ` false`.
Esta función utiliza la semántica «adquirir- memory ordering », que garantiza que el acceso a la memoria posterior a la operación atómica (en el orden del programa) no pueda reordenarse antes de dicha operación atómica.
bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue, T ¤tValue)
Prueba y establecimiento atómico.
Si el valor actual de este ` QAtomicInteger ` es el ` expectedValue`, las funciones «test-and-set» asignan el ` newValue ` a este ` QAtomicInteger ` y devuelven ` true`. Si los valores no coinciden, las funciones cargan el valor actual de este ` QAtomicInteger ` en ` currentValue ` y devuelven ` false`.
Esta función utiliza la semántica «acquire» memory ordering, que garantiza que el acceso a la memoria posterior a la operación atómica (en el orden del programa) no pueda reordenarse antes de la operación atómica. Si la operación «test-and-set» falla, el currentValue se carga con la semántica «acquire» memory ordering.
bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue)
Prueba y establecimiento atómicos.
Nota: Si utilizas esta función en un bucle, considera utilizar en su lugar la sobrecarga con el argumento adicional ` T ¤tValue `, lo que evita la llamada adicional a ` loadAcquire()` en caso de fallo.
Si el valor actual de este ` QAtomicInteger ` es el ` expectedValue`, las funciones de comprobación y asignación asignan el ` newValue ` a este ` QAtomicInteger ` y devuelven `true`. Si los valores no coinciden, esta función no realiza ninguna acción y devuelve ` false`.
Esta función utiliza la semántica « memory ordering », que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse.
bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue, T ¤tValue)
Prueba y establecimiento atómicos.
Si el valor actual de este QAtomicInteger es el expectedValue, las funciones de prueba y asignación asignan el newValue a este QAtomicInteger y devuelven true. Si los valores no coinciden, carga el valor actual de este QAtomicInteger en currentValue y devuelve false.
Esta función utiliza la semántica ordenada de « memory ordering », que garantiza que el acceso a la memoria antes y después de la operación atómica (en el orden del programa) no pueda reordenarse. Si la operación «test-and-set» falla, el currentValue se carga con la semántica «acquire» memory ordering.
bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue)
Prueba y establecimiento atómicos.
Nota: Si utilizas esta función en un bucle, considera utilizar en su lugar la sobrecarga con el argumento adicional ` T ¤tValue `, lo que evita la llamada adicional a ` loadRelaxed()` en caso de fallo.
Si el valor actual de este ` QAtomicInteger ` es el ` expectedValue`, las funciones de comprobación y asignación asignan el ` newValue ` a este ` QAtomicInteger ` y devuelven `true`. Si los valores no coinciden, esta función no realiza ninguna acción y devuelve ` false`.
Esta función utiliza una semántica « memory ordering » relajada, lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria.
bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue, T ¤tValue)
Prueba y establecimiento atómico.
Si el valor actual de este QAtomicInteger es el expectedValue, las funciones «test-and-set» asignan el newValue a este QAtomicInteger y devuelven true. Si los valores no coinciden, las funciones cargan el valor actual de este QAtomicInteger en currentValue y devuelven false.
Esta función utiliza la semántica relajada memory ordering, lo que permite al compilador y al procesador reordenar libremente los accesos a la memoria. Si la operación «test-and-set» falla, el currentValue se carga con la semántica relajada memory ordering.
bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue)
Prueba y establecimiento atómicos.
Nota: Si utilizas esta función en un bucle, considera utilizar en su lugar la sobrecarga con el argumento adicional ` T ¤tValue `, lo que evita la llamada adicional a ` loadRelaxed()` en caso de fallo.
Si el valor actual de este ` QAtomicInteger ` es el ` expectedValue`, las funciones de comprobación y asignación asignan el ` newValue ` a este ` QAtomicInteger ` y devuelven `true`. Si los valores no coinciden, esta función no realiza ninguna acción y devuelve ` false`.
Esta función utiliza la semántica «release memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica.
bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue, T ¤tValue)
Prueba y establecimiento atómicos.
Si el valor actual de este QAtomicInteger es el expectedValue, las funciones de prueba y establecimiento asignan el newValue a este QAtomicInteger y devuelven true. Si los valores no son iguales, las funciones cargan el valor actual de este QAtomicInteger en currentValue y devuelven false.
Esta función utiliza la semántica «release - memory ordering », que garantiza que el acceso a la memoria anterior a la operación atómica (en el orden del programa) no pueda reordenarse después de la operación atómica. Si la operación «test-and-set» falla, currentValue se carga con la semántica «relaxed - memory ordering ».
QAtomicInteger::operator T() const
Carga de forma atómica el valor de este QAtomicInteger utilizando un orden de memoria secuencialmente consistente si es posible; o el orden «Acquire» si no lo es. El valor no se modifica de ninguna manera, pero hay que tener en cuenta que no hay garantía de que siga siendo así.
Véase también loadRelaxed() y loadAcquire().
T QAtomicInteger::operator&=(T value)
Operación atómica de suma y recuperación.
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación AND bit a bit c value al valor actual, devolviendo el nuevo valor.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; de lo contrario, utiliza el orden «Ordered».
Véase también fetchAndAndOrdered().
T QAtomicInteger::operator++()
Preincrementa de forma atómica el valor de este QAtomicInteger. Devuelve el nuevo valor de este elemento atómico.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; de lo contrario, utiliza el orden «Ordered».
Véase también ref(), operator++(int) y operator--().
T QAtomicInteger::operator++(int)
Realiza un incremento posterior atómico del valor de este « QAtomicInteger ». Devuelve el valor anterior de este «atomic».
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; de lo contrario, utiliza el orden «Ordered».
Véase también ref(), operator++() y operator--(int).
T QAtomicInteger::operator+=(T value)
Operación atómica de «añadir y recuperar».
Lee el valor actual de este QAtomicInteger y, a continuación, suma value al valor actual, devolviendo el nuevo valor.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; o un orden «ordenado» si no lo es.
Véanse también fetchAndAddOrdered() y operator-=().
T QAtomicInteger::operator--()
Disminuye de forma atómica el valor de este « QAtomicInteger ». Devuelve el nuevo valor de este «atomic».
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; en caso contrario, utiliza el orden «Ordered».
Véase también deref(), operator--(int) y operator++().
T QAtomicInteger::operator--(int)
Realiza un posdecremento atómico del valor de este « QAtomicInteger ». Devuelve el valor anterior de este «atomic».
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; de lo contrario, utiliza el orden «Ordered».
Véase también deref(), operator--() y operator++(int).
T QAtomicInteger::operator-=(T value)
Operación atómica «sub-and-fetch».
Lee el valor actual de este QAtomicInteger y, a continuación, resta value del valor actual, devolviendo el nuevo valor.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; o bien el orden «Ordered» si no lo es.
Véanse también fetchAndSubOrdered() y operator+=().
QAtomicInteger<T> &QAtomicInteger::operator=(T)
Almacena de forma atómica el otro valor en este tipo atómico utilizando un orden de memoria secuencialmente consistente, si es posible; o el orden «Release», si no lo es. Esta función devuelve una referencia a este objeto.
Véase también storeRelaxed() y storeRelease().
[noexcept] QAtomicInteger<T> &QAtomicInteger::operator=(const QAtomicInteger<T> &other)
Asigna other a este QAtomicInteger y devuelve una referencia a este QAtomicInteger.
T QAtomicInteger::operator^=(T value)
Operación atómica XOR y lectura.
Lee el valor actual de este QAtomicInteger y, a continuación, aplica una operación XOR bit a bit value al valor actual, devolviendo el nuevo valor.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; de lo contrario, utiliza el orden «Ordered».
Véase también ` fetchAndXorOrdered()`.
T QAtomicInteger::operator|=(T value)
Operación atómica «OR» y «FETCH».
Lee el valor actual de este « QAtomicInteger » y, a continuación, realiza una operación OR bit a bit entre « value » y el valor actual, devolviendo el nuevo valor.
Esta función utiliza un orden de memoria secuencialmente consistente si es posible; en caso contrario, utiliza el orden «Ordered».
Véase también fetchAndOrOrdered().
Elementos no miembros relacionados
[noexcept, since 6.7] void qYieldCpu()
Detiene la ejecución del hilo actual durante un tiempo no especificado, utilizando instrucciones de hardware, sin eliminar dicho hilo de la lista de ejecución. Esta función está pensada para utilizarse en bucles de alto rendimiento en los que el código espera que otro hilo modifique una variable atómica. Esto es completamente diferente de ` QThread::yieldCurrentThread()`, que es una operación a nivel del sistema operativo que puede retirar todo el hilo de la CPU y permitir que se ejecuten otros hilos (posiblemente pertenecientes a otros procesos).
Por lo tanto, en lugar de
while (!condition)
;se debería escribir
while (!condition)
qYieldCpu();Esto resulta útil tanto con como sin multihilo por hardware en el mismo núcleo. En el caso de los hilos de hardware, sirve para evitar que una mayor ejecución especulativa llene la canalización, lo que podría privar de recursos al hilo hermano. Entre núcleos y en niveles superiores de separación, permite que el protocolo de coherencia de caché asigne la línea de caché que se está modificando e inspeccionando al procesador lógico cuyo resultado espera este código.
También se recomienda rodear de un bucle el código que no modifique la variable global, para evitar conflictos a la hora de obtener en exclusiva la ubicación de memoria. Por lo tanto, un bucle de modificación atómica, como la adquisición de un spinlock, debería ser:
while (true) {
while (!readOnlyCondition(atomic))
qYieldCpu();
if (modify(atomic))
break;
}En procesadores x86 y en procesadores RISC-V con la extensión « Zihintpause », esto emitirá la instrucción « PAUSE », que se ignora en los procesadores que no la admiten; en procesadores ARMv7 o posteriores, emitirá la instrucción « YIELD ».
Esta función se introdujo en Qt 6.7.
Documentación de macros
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_ALWAYS_NATIVE
Esta macro está definida si y solo si tu procesador admite la operación atómica «fetch-and-add» con números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_NOT_NATIVE
Esta macro se define cuando el hardware no admite operaciones atómicas de lectura y suma con números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
Esta macro se define cuando solo determinadas generaciones del procesador admiten la operación atómica «fetch-and-add» con números enteros. Utiliza la función QAtomicInteger::isFetchAndAddNative() para comprobar qué operaciones admite tu procesador.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_WAIT_FREE
Esta macro se define junto con « Q_ATOMIC_INTnn_FETCH_AND_ADD_IS_ALWAYS_NATIVE » para indicar que la operación atómica «fetch-and-add» sobre enteros no implica espera.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE
Esta macro está definida si y solo si el procesador admite operaciones atómicas de lectura y escritura en números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_NOT_NATIVE
Esta macro se define cuando el hardware no admite operaciones atómicas de lectura y escritura en números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
Esta macro se define cuando solo determinadas generaciones del procesador admiten operaciones atómicas de lectura y escritura en números enteros. Utiliza la función QAtomicInteger::isFetchAndStoreNative() para comprobar qué funciones admite tu procesador.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_WAIT_FREE
Esta macro se define junto con « Q_ATOMIC_INTnn_FETCH_AND_STORE_IS_ALWAYS_NATIVE » para indicar que la operación atómica de lectura y escritura en números enteros no implica espera.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_IS_SUPPORTED
Esta macro se define si esta combinación de compilador y arquitectura admite enteros atómicos de tamaño nn (en bits).
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Las siguientes macros están siempre definidas:
- Q_ATOMIC_INT8_IS_SUPPORTED
- Q_ATOMIC_INT16_IS_SUPPORTED
- Q_ATOMIC_INT32_IS_SUPPORTED
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
Esta macro está definida si y solo si todas las generaciones de tu procesador admiten el recuento atómico de referencias.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_NOT_NATIVE
Esta macro se define cuando el hardware no admite el recuento atómico de referencias.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE
Esta macro se define cuando solo determinadas generaciones del procesador admiten el recuento atómico de referencias. Utiliza la función QAtomicInteger::isReferenceCountingNative() para comprobar qué admite tu procesador.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_WAIT_FREE
Esta macro se define junto con « Q_ATOMIC_INTnn_REFERENCE_COUNTING_IS_ALWAYS_NATIVE » para indicar que el recuento de referencias no implica espera.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_ALWAYS_NATIVE
Esta macro se define si y solo si el procesador admite la operación atómica «test-and-set» con números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_NOT_NATIVE
Esta macro se define cuando el hardware no admite la operación atómica «test-and-set» con números enteros.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_SOMETIMES_NATIVE
Esta macro se define cuando solo determinadas generaciones del procesador admiten la operación atómica «test-and-set» con números enteros. Utiliza la función ` QAtomicInteger::isTestAndSetNative()` para comprobar qué operaciones admite tu procesador.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
Q_ATOMIC_INTnn_TEST_AND_SET_IS_WAIT_FREE
Esta macro se define junto con ` Q_ATOMIC_INTnn_TEST_AND_SET_IS_ALWAYS_NATIVE ` para indicar que la operación atómica «test-and-set» sobre enteros no implica espera.
nn es el tamaño del entero, en bits (8, 16, 32 o 64).
© 2026 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.