QAtomicInteger Class

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;
}

if (currentValue == expectedValue) {
    currentValue = newValue;
    return true;
}
return false;

int originalValue = currentValue;
currentValue = newValue;
return originalValue;

int originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;

成员函数文档

[constexpr noexcept] QAtomicInteger::QAtomicInteger(T value = 0)

使用给定的value 构建一个QAtomicInteger。

[noexcept] QAtomicInteger::QAtomicInteger(const QAtomicInteger<T> &other)

创建other 的副本。

bool QAtomicInteger::deref()

以原子方式将该QAtomicInteger 的值递减。如果新值不为零，则返回true ；否则返回false。

该函数采用有序的 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

另请参阅 ref() 和operator--()。

T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)

原子读取并加法。

读取该QAtomicInteger 的当前值，然后将valueToAdd 加到当前值上，并返回原始值。

该函数采用“获取” memory ordering 语义，这确保了（按程序顺序）在原子操作之后进行的内存访问，不会被重新排序至原子操作之前。

另请参阅 operator+=() 和fetchAndSubAcquire()。

T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)

原子读取并加法操作。

读取该QAtomicInteger 的当前值，然后将valueToAdd 加到当前值上，并返回原始值。

该函数采用有序 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

另请参阅 operator+=() 和fetchAndSubOrdered()。

T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)

原子读取-累加。

读取该QAtomicInteger 的当前值，然后将valueToAdd 加到当前值上，并返回原始值。

此函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问。

另请参阅 operator+=() 和fetchAndSubRelaxed()。

T QAtomicInteger::fetchAndAddRelease(T valueToAdd)

原子读取并加法。

读取该QAtomicInteger 的当前值，然后将valueToAdd 加到当前值上，并返回原始值。

该函数采用“释放-memory ordering ”语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

另请参阅 operator+=() 和fetchAndSubRelease()。

T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)

原子读取并与运算。

读取该QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行位与运算，并返回原始值。

该函数采用“获取” memory ordering 语义，这确保了在原子操作之后（按程序顺序）的内存访问不会被重新排序至原子操作之前。

另请参阅 operator&=()。

T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)

原子读取并与运算。

读取该QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行位与运算，并返回原始值。

该函数采用有序 memory ordering 语义，这确保了（按程序顺序）原子操作之前和之后的内存访问不会被重新排序。

另请参阅 operator&=()。

T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)

原子读取并按位与运算。

读取该QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行位与运算，并返回原始值。

此函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问操作。

另请参阅 operator&=()。

T QAtomicInteger::fetchAndAndRelease(T valueToAnd)

原子读取并按位与运算。

读取该QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行位与运算，并返回原始值。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

另请参阅 operator&=()。

T QAtomicInteger::fetchAndOrAcquire(T valueToOr)

原子读取并或运算。

读取该QAtomicInteger 的当前值，然后将valueToOr 与当前值进行按位或运算，并返回原始值。

该函数采用“获取-memory ordering ”语义，这确保了在原子操作之后（按程序顺序）的内存访问不会被重新排序至原子操作之前。

另请参阅 operator|=()。

T QAtomicInteger::fetchAndOrOrdered(T valueToOr)

原子读取并或运算。

读取该QAtomicInteger 的当前值，然后将valueToOr 与当前值进行按位或运算，并返回原始值。

该函数采用有序 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

另请参阅 operator|=()。

T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)

原子读取并或运算。

读取该QAtomicInteger 的当前值，然后将valueToOr 与当前值进行按位或运算，并返回原始值。

该函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问。

另请参阅 operator|=()。

T QAtomicInteger::fetchAndOrRelease(T valueToOr)

原子读取并或运算。

读取该QAtomicInteger 的当前值，然后将valueToOr 与当前值进行按位或运算，并返回原始值。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

另请参阅 operator|=()。

T QAtomicInteger::fetchAndStoreAcquire(T newValue)

原子读取-存储操作。

读取该QAtomicInteger 的当前值，然后将其赋值为newValue ，并返回原始值。

该函数采用“获取-memory ordering ”语义，这确保了在原子操作之后（按程序顺序）的内存访问，不会被重新排序至原子操作之前。

T QAtomicInteger::fetchAndStoreOrdered(T newValue)

原子读取和存储。

读取该QAtomicInteger 的当前值，然后将其赋值为newValue ，并返回原始值。

该函数采用有序 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

T QAtomicInteger::fetchAndStoreRelaxed(T newValue)

原子读取-存储操作。

读取该QAtomicInteger 的当前值，然后将其赋值为newValue ，并返回原始值。

该函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问操作。

T QAtomicInteger::fetchAndStoreRelease(T newValue)

原子读取-存储操作。

读取该QAtomicInteger 的当前值，然后将其赋值给newValue ，并返回原始值。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

T QAtomicInteger::fetchAndSubAcquire(T valueToSub)

原子读取并减法。

读取该QAtomicInteger 的当前值，然后从当前值中减去valueToSub ，并返回原始值。

该函数使用“获取” memory ordering 语义，这确保了（按程序顺序）在原子操作之后进行的内存访问不会被重新排序到原子操作之前。

另请参阅 operator-=() 和fetchAndAddAcquire()。

T QAtomicInteger::fetchAndSubOrdered(T valueToSub)

原子读取并减法。

读取该QAtomicInteger 的当前值，然后从当前值中减去valueToSub ，并返回原始值。

该函数采用有序 memory ordering 语义，这确保了（按程序顺序）原子操作之前和之后的内存访问不会被重新排序。

另请参阅 operator-=() 和fetchAndAddOrdered()。

T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)

原子获取并减法。

读取该QAtomicInteger 的当前值，然后从当前值中减去valueToSub ，并返回原始值。

此函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问。

另请参阅 operator-=() 和fetchAndAddRelaxed()。

T QAtomicInteger::fetchAndSubRelease(T valueToSub)

原子读取并减法。

读取该QAtomicInteger 的当前值，然后将valueToSub 从当前值中减去，并返回原始值。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）原子操作之前的内存访问在原子操作之后不会被重新排序。

另请参见 operator-=() 和fetchAndAddRelease()。

T QAtomicInteger::fetchAndXorAcquire(T valueToXor)

原子获取并异或。

读取该QAtomicInteger 的当前值，然后将valueToXor 与当前值进行位异或运算，并返回原始值。

该函数采用“获取” memory ordering 语义，这确保了（按程序顺序）紧随原子操作之后的内存访问，不会被重新排序至该原子操作之前。

另请参阅 operator^=()。

T QAtomicInteger::fetchAndXorOrdered(T valueToXor)

原子取值并异或。

读取该QAtomicInteger 的当前值，然后将valueToXor 与当前值进行位异或运算，并返回原始值。

该函数采用有序的 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

另请参阅 operator^=()。

T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)

原子获取并异或。

读取该QAtomicInteger 的当前值，然后将valueToXor 与当前值进行位异或运算，并返回原始值。

此函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问。

另请参阅 operator^=()。

T QAtomicInteger::fetchAndXorRelease(T valueToXor)

原子获取并异或。

读取该QAtomicInteger 的当前值，然后将valueToXor 与当前值进行位异或运算，并返回原始值。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

另请参阅 operator^=()。

[static constexpr] bool QAtomicInteger::isFetchAndAddNative()

如果 `fetch-and-add` 是通过原子处理器指令实现的，则返回 `true `；否则返回 `false`。

[static constexpr] bool QAtomicInteger::isFetchAndAddWaitFree()

如果原子“读取并添加”操作是无等待的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isFetchAndStoreNative()

如果“fetch-and-store”操作是通过原子处理器指令实现的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isFetchAndStoreWaitFree()

如果原子读取-存储操作是无等待的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isReferenceCountingNative()

如果引用计数是通过原子处理器指令实现的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isReferenceCountingWaitFree()

如果原子引用计数是无等待的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isTestAndSetNative()

如果“测试并设置”操作是通过原子处理器指令实现的，则返回true ；否则返回false。

[static constexpr] bool QAtomicInteger::isTestAndSetWaitFree()

如果原子“测试并设置”操作是无等待的，则返回true ；否则返回false。

T QAtomicInteger::loadAcquire() const

使用“Acquire”内存排序原子地加载此QAtomicInteger 的值。该值不会以任何方式被修改，但请注意，无法保证其值保持不变。

另请参阅 storeRelaxed() 和loadRelaxed()。

T QAtomicInteger::loadRelaxed() const

使用松弛内存排序原子地加载该QAtomicInteger 的值。该值不会以任何方式被修改，但请注意，无法保证其值保持不变。

另请参阅 storeRelaxed() 和loadAcquire()。

bool QAtomicInteger::ref()

以原子方式递增此QAtomicInteger 的值。如果新值不为零，则返回true ；否则返回false。

该函数采用有序的 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

另请参阅 deref() 和operator++()。

void QAtomicInteger::storeRelaxed(T newValue)

将newValue 的值以原子方式存储到此原子类型中，并采用宽松的内存排序规则。

另请参阅 storeRelease() 和loadRelaxed()。

void QAtomicInteger::storeRelease(T newValue)

将newValue 的值以原子方式存储到此原子类型中，并采用“Release”内存排序。

另请参阅 storeRelaxed() 和loadAcquire()。

bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue)

原子测试与设置。

如果该QAtomicInteger 的当前值即为expectedValue ，则“测试并设置”函数将newValue 赋值给该QAtomicInteger ，并返回true。如果两者值不同，则该函数不执行任何操作，并返回false 。

该函数采用“获取” memory ordering 语义，这确保了在原子操作之后（按程序顺序）的内存访问，不会被重新排序到原子操作之前。

bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue, T &currentValue)

原子测试并设置。

如果该QAtomicInteger 的当前值是expectedValue ，则“测试并设置”函数会将newValue 赋值给该QAtomicInteger ，并返回true 。如果两个值不相同，则这些函数会将该QAtomicInteger 的当前值加载到currentValue 中，并返回false 。

该函数采用“获取” memory ordering 语义，这确保了在原子操作之后（按程序顺序）的内存访问不会被重新排序至原子操作之前。如果“测试并设置”操作失败，则currentValue 将采用“获取” memory ordering 语义进行加载。

bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue)

原子测试与设置。

如果该QAtomicInteger 的当前值即为expectedValue ，则“测试并设置”函数会将newValue 赋值给该QAtomicInteger ，并返回true。如果两个值不相同，则该函数不执行任何操作，并返回false 。

该函数采用有序的 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不会被重新排序。

bool QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue, T &currentValue)

原子测试并设置。

如果该QAtomicInteger 的当前值是expectedValue ，则“测试并设置”函数将newValue 赋值给该QAtomicInteger ，并返回true 。如果两个值不相同，则将该QAtomicInteger 的当前值加载到currentValue 中，并返回false 。

该函数采用有序的 memory ordering 语义，这确保了原子操作前后（按程序顺序）的内存访问不得被重新排序。如果“测试并设置”操作失败，则currentValue 将采用acquire memory ordering 语义进行加载。

bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue)

原子测试与设置。

如果该QAtomicInteger 的当前值即为expectedValue ，则“测试并设置”函数会将newValue 赋值给该QAtomicInteger ，并返回true。如果两个值不相同，则该函数不执行任何操作，并返回false 。

该函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问操作。

bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue, T &currentValue)

原子测试并设置。

如果该QAtomicInteger 的当前值是expectedValue ，则“测试并设置”函数会将newValue 赋值给该QAtomicInteger ，并返回true 。如果两者值不相同，则函数会将该QAtomicInteger 的当前值加载到currentValue 中，并返回false 。

该函数采用宽松的 memory ordering 语义，允许编译器和处理器自由重新排序内存访问。如果“测试并设置”操作失败，则会采用宽松的 memory ordering 语义将currentValue 加载进来。

bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue)

原子测试与设置。

如果该QAtomicInteger 的当前值即为expectedValue ，则“测试并设置”函数会将newValue 赋值给该QAtomicInteger ，并返回true。如果两个值不相同，则该函数不执行任何操作，并返回false 。

该函数采用memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。

bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue, T &currentValue)

原子测试并设置。

如果该QAtomicInteger 的当前值是expectedValue ，则“测试并设置”函数将newValue 赋值给该QAtomicInteger ，并返回true 。如果两个值不相同，则该函数将该QAtomicInteger 的当前值加载到currentValue 中，并返回false 。

该函数采用“释放” memory ordering 语义，这确保了（按程序顺序）在原子操作之前进行的内存访问，在原子操作之后不会被重新排序。如果“测试并设置”操作失败，则currentValue 将采用“宽松” memory ordering 语义进行加载。

QAtomicInteger::operator T() const

如果可能，则使用顺序一致的内存排序原子地加载此QAtomicInteger 的值；否则使用“Acquire”排序。该值不会以任何方式被修改，但请注意，无法保证其值保持不变。

另请参阅 loadRelaxed() 和loadAcquire()。

T QAtomicInteger::operator&=(T value)

原子加法和读取操作。

读取该QAtomicInteger 的当前值，然后将value 与当前值进行位与运算，并返回新值。

该函数在可能的情况下使用顺序一致的内存排序；否则使用“有序”排序。

另请参阅 fetchAndAndOrdered()。

T QAtomicInteger::operator++()

以原子方式将该QAtomicInteger 的值预递增。返回该原子变量的新的值。

该函数在可能的情况下采用顺序一致的内存排序；否则采用“有序”排序。

另请参阅 ref()、operator++(int) 以及operator--()。

T QAtomicInteger::operator++(int)

以原子方式对该QAtomicInteger 的值进行后递增操作。返回该原子值的旧值。

该函数在可能的情况下采用顺序一致的内存排序；否则采用“有序”排序。

另请参阅 ref()、operator++() 以及operator--(int)。

T QAtomicInteger::operator+=(T value)

原子加法和读取操作。

读取该QAtomicInteger 的当前值，然后将value 加到当前值上，并返回新值。

如果可能，此函数使用顺序一致的内存排序；否则使用“有序”排序。

另请参阅 fetchAndAddOrdered() 和operator-=()。

T QAtomicInteger::operator--()

以原子方式对该QAtomicInteger 的值进行预递减。返回该原子变量的新的值。

该函数在可能的情况下采用顺序一致的内存排序；否则采用“有序”排序。

另请参阅 deref()、operator--(int) 以及operator++()。

T QAtomicInteger::operator--(int)

以原子方式对该QAtomicInteger 的值进行后减操作。返回该原子值的旧值。

该函数在可能的情况下采用顺序一致的内存排序；否则采用“有序”排序。

另请参阅 deref()、operator--() 以及operator++(int)。

T QAtomicInteger::operator-=(T value)

原子子操作和读取。

读取该QAtomicInteger 的当前值，然后从当前值中减去value ，并返回新值。

如果可能，此函数将使用顺序一致的内存排序；否则将使用“有序”排序。

另请参阅 fetchAndSubOrdered() 和operator+=()。

QAtomicInteger<T> &QAtomicInteger::operator=(T)

如果可能，则使用顺序一致的内存排序将另一个值原子地存储到此原子类型中；否则使用“释放”排序。该函数返回对此对象的引用。

另请参阅 storeRelaxed() 和storeRelease()。

[noexcept] QAtomicInteger<T> &QAtomicInteger::operator=(const QAtomicInteger<T> &other)

将other 赋值给此QAtomicInteger ，并返回对此QAtomicInteger 的引用。

T QAtomicInteger::operator^=(T value)

原子异或并取值操作。

读取该QAtomicInteger 的当前值，然后将value 与当前值进行按位异或运算，并返回新值。

该函数在可能的情况下采用顺序一致的内存排序；否则采用“有序”排序。

另请参阅 fetchAndXorOrdered()。

T QAtomicInteger::operator|=(T value)

原子操作“或-且-读取”。

读取该QAtomicInteger 的当前值，然后将value 与当前值进行按位或运算，并返回新值。

该函数在可能的情况下使用顺序一致的内存排序；否则使用“有序”排序。

另请参阅 fetchAndOrOrdered()。

while (!condition)
    ;

while (!condition)
    qYieldCpu();

while (true) {
    while (!readOnlyCondition(atomic))
        qYieldCpu();
    if (modify(atomic))
        break;
}