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 添加到当前值，返回原始值。

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

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

T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)

原子取加。

读取QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行比特-并，返回原始值。

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

另请参见 operator&=()。

T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)

原子取加。

读取QAtomicInteger 的当前值，然后将valueToAnd 与当前值比特-AND，返回原始值。

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

另请参见 operator&=()。

T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)

原子取加。

读取QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行比特-并，返回原始值。

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

另请参见 operator&=()。

T QAtomicInteger::fetchAndAndRelease(T valueToAnd)

原子取加。

读取QAtomicInteger 的当前值，然后将valueToAnd 与当前值进行比特-并，返回原始值。

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

另请参见 operator&=()。

T QAtomicInteger::fetchAndOrAcquire(T valueToOr)

原子取值-和-或。

读取QAtomicInteger 的当前值，然后将valueToOr 与当前值进行比特-OR，返回原始值。

该函数使用获取 memory ordering 语义，确保原子操作后的内存访问（按程序顺序）不得在原子操作前重新排序。

另请参见 operator|=()。

T QAtomicInteger::fetchAndOrOrdered(T valueToOr)

原子取值-和-或。

读取QAtomicInteger 的当前值，然后将valueToOr 与当前值进行比特-OR，返回原始值。

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

另请参见 operator|=()。

T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)

原子取值-和-或。

读取QAtomicInteger 的当前值，然后将valueToOr 与当前值位相 OR，返回原始值。

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

另请参见 operator|=()。

T QAtomicInteger::fetchAndOrRelease(T valueToOr)

原子取值-和-或。

读取QAtomicInteger 的当前值，然后将valueToOr 与当前值进行比特-OR，返回原始值。

该函数使用release 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 ，返回原始值。

该函数使用release 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 的当前值，返回原始值。

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

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

T QAtomicInteger::fetchAndXorAcquire(T valueToXor)

原子取值-XOR。

读取QAtomicInteger 的当前值，然后将valueToXor 与当前值进行比特-XOR，返回原始值。

该函数使用获取 memory ordering 语义，确保原子操作后的内存访问（按程序顺序）不得在原子操作前重新排序。

另请参见 operator^=()。

T QAtomicInteger::fetchAndXorOrdered(T valueToXor)

原子取值-XOR。

读取QAtomicInteger 的当前值，然后将valueToXor 与当前值进行比特-XOR，返回原始值。

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

另请参见 operator^=()。

T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)

原子取值-XOR。

读取QAtomicInteger 的当前值，然后将valueToXor 与当前值进行比特-XOR，最后返回原始值。

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

另请参见 operator^=()。

T QAtomicInteger::fetchAndXorRelease(T valueToXor)

原子取值-XOR。

读取QAtomicInteger 的当前值，然后将valueToXor 与当前值进行比特-XOR，返回原始值。

该函数使用release memory ordering 语义，确保原子操作前的内存访问（按程序顺序）在原子操作后不得重新排序。

另请参见 operator^=()。

[static constexpr] bool QAtomicInteger::isFetchAndAddNative()

如果取加是使用原子处理器指令实现的，则返回true ，否则返回 false。

[static constexpr] bool QAtomicInteger::isFetchAndAddWaitFree()

如果原子取加是免等待的，则返回true ，否则返回 false。

[static constexpr] bool QAtomicInteger::isFetchAndStoreNative()

如果使用原子处理器指令实现取存，则返回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

使用 "获取 "内存排序，原子加载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 值原子存储到该原子类型中。

另请参阅 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 语义，确保原子操作之后的内存访问（按程序顺序）不得在原子操作之前重新排序。

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 语义，确保原子操作前后的内存访问（按程序顺序）不得重新排序。

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 语义，让编译器和处理器自由地重新安排内存访问顺序。

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

原子测试和设置。

如果此QAtomicInteger 的当前值是expectedValue ，则测试和设置函数会将newValue 分配给此QAtomicInteger 并返回 true。如果值不相同，则该函数不会执行任何操作，并返回false 。

该函数使用release memory ordering 语义，确保原子操作前的内存访问（按程序顺序）在原子操作后不得重新排序。

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

原子测试和设置。

如果QAtomicInteger 的当前值是expectedValue ，则测试和设置函数会将newValue 分配给QAtomicInteger ，并返回true 。如果值不相同，函数会将QAtomicInteger 的当前值加载到currentValue ，并返回false 。

该函数使用release memory ordering 语义，确保原子操作前的内存访问（按程序顺序）在原子操作后不得重新排序。

T QAtomicInteger::operator T() const

如果可能，使用顺序一致的内存排序方式原子加载QAtomicInteger 的值；如果不可能，则使用 "获取 "排序方式。该值不会以任何方式被修改，但要注意的是，并不能保证它始终如此。

另请参阅 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)

原子 xor 和取值。

读取QAtomicInteger 的当前值，然后将value 与当前值进行比特 XOR，返回新值。

如果可能，该函数使用顺序一致的内存排序；如果不可能，则使用 "有序 "排序。

另请参见 fetchAndXorOrdered()。

T QAtomicInteger::operator|=(T value)

原子或和取。

读取QAtomicInteger 的当前值，然后将value 与当前值位相 OR，返回新值。

如果可能，该函数使用顺序一致的内存排序；如果不可能，则使用 "有序 "排序。

另请参见 fetchAndOrOrdered()。

while (!condition)
    ;

while (!condition)
    qYieldCpu();

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