QAtomicInteger 类

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。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

另见 ref() 和 操作符--.

T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)

原子获取加。

读取此QAtomicInteger的当前值，然后将valueToAdd添加到当前值，返回原始值。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

另见 操作符+=() 和 fetchAndSubAcquire().

T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)

原子获取加。

读取此QAtomicInteger的当前值，然后将valueToAdd添加到当前值，返回原始值。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

另见 操作符+=() 和 fetchAndSubOrdered().

T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)

原子获取加。

读取此QAtomicInteger的当前值，然后将valueToAdd添加到当前值，返回原始值。

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

另见 操作符+=() 和 fetchAndSubRelaxed().

T QAtomicInteger::fetchAndAddRelease(T valueToAdd)

原子获取加。

读取此QAtomicInteger的当前值，然后将valueToAdd添加到当前值，返回原始值。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

另见 操作符+=() 和 fetchAndSubRelease().

T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)

原子获取与。

读取此QAtomicInteger的当前值，然后将valueToAnd与当前值进行位与操作，返回原始值。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

另见 操作符&=().

T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)

原子获取与。

读取此QAtomicInteger的当前值，然后将valueToAnd与当前值进行位与操作，返回原始值。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

另见 操作符&=().

T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)

原子获取与。

读取此QAtomicInteger的当前值，然后将valueToAnd与当前值进行位与操作，返回原始值。

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

另见 操作符&=().

T QAtomicInteger::fetchAndAndRelease(T valueToAnd)

原子获取与。

读取此QAtomicInteger的当前值，然后将valueToAnd与当前值进行位与操作，返回原始值。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

另见 操作符&=().

T QAtomicInteger::fetchAndOrAcquire(T valueToOr)

原子获取或。

读取此QAtomicInteger的当前值，然后将valueToOr与当前值进行位或操作，返回原始值。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

另见 操作符|=().

T QAtomicInteger::fetchAndOrOrdered(T valueToOr)

原子获取或。

读取此QAtomicInteger的当前值，然后将valueToOr与当前值进行位或操作，返回原始值。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

另见 操作符|=().

T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)

原子获取或。

读取此QAtomicInteger的当前值，然后将valueToOr与当前值进行位或操作，返回原始值。

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

另见 操作符|=().

T QAtomicInteger::fetchAndOrRelease(T valueToOr)

原子获取或。

读取此QAtomicInteger的当前值，然后将valueToOr与当前值进行位或操作，返回原始值。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

另见 操作符|=().

T QAtomicInteger::fetchAndStoreAcquire(T newValue)

原子fetch-and-store。

读取此QAtomicInteger的当前值，然后将其分配给newValue，返回原始值。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

T QAtomicInteger::fetchAndStoreOrdered(T newValue)

原子fetch-and-store。

读取此QAtomicInteger的当前值，然后将其分配给newValue，返回原始值。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

T QAtomicInteger::fetchAndStoreRelaxed(T newValue)

原子fetch-and-store。

读取此QAtomicInteger的当前值，然后将其分配给newValue，返回原始值。

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

T QAtomicInteger::fetchAndStoreRelease(T newValue)

原子fetch-and-store。

读取此QAtomicInteger的当前值，然后将其分配给newValue，返回原始值。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

T QAtomicInteger::fetchAndSubAcquire(T valueToSub)

原子fetch-and-sub。

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

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

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

T QAtomicInteger::fetchAndSubOrdered(T valueToSub)

原子fetch-and-sub。

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

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

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

T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)

原子fetch-and-sub。

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

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

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

T QAtomicInteger::fetchAndSubRelease(T valueToSub)

原子fetch-and-sub。

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

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

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

T QAtomicInteger::fetchAndXorAcquire(T valueToXor)

原子fetch-and-xor。

读取此QAtomicInteger的当前值，然后对当前值执行与valueToXor的位异或，返回原始值。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

另请参阅operator^=。

T QAtomicInteger::fetchAndXorOrdered(T valueToXor)

原子fetch-and-xor。

读取此QAtomicInteger的当前值，然后对当前值执行与valueToXor的位异或，返回原始值。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

另请参阅operator^=。

T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)

原子fetch-and-xor。

读取此QAtomicInteger的当前值，然后对当前值执行与valueToXor的位异或，返回原始值。

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

另请参阅operator^=。

T QAtomicInteger::fetchAndXorRelease(T valueToXor)

原子fetch-and-xor。

读取此QAtomicInteger的当前值，然后对当前值执行与valueToXor的位异或，返回原始值。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

另请参阅operator^=。

[static constexpr] bool QAtomicInteger::isFetchAndAddNative()

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

[static constexpr] bool QAtomicInteger::isFetchAndAddWaitFree()

如果原子fetch-and-add是wait-free，则返回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。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

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

void QAtomicInteger::storeRelaxed(T newValue)

使用松散内存顺序将新值原子地存储到此原子类型中。

另请参阅storeRelease() 和 loadRelaxed。

void QAtomicInteger::storeRelease(T newValue)

使用 "释放" 内存顺序将新值原子地存储到此原子类型中。

另请参阅storeRelaxed() 和 loadAcquire。

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

原子测试并设置。

如果此 QAtomicInteger 的当前值是 expectedValue，则测试和设置函数将会将 newValue 赋值给此 QAtomicInteger 并返回 true。如果值 不 相同，此函数不会做任何事情，并返回 false。

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

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

原子测试并设置。

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

此函数使用了获取内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不能在原子操作之前重排序。

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

原子测试并设置。

如果此 QAtomicInteger 的当前值是 expectedValue，则测试和设置函数将会将 newValue 赋值给此 QAtomicInteger 并返回 true。如果值 不 相同，此函数不会做任何事情，并返回 false。

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

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

原子测试并设置。

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

此函数使用了内存顺序语义，这确保了在原子操作前后（按程序顺序）对内存的访问不能重排序。

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

原子测试并设置。

如果此 QAtomicInteger 的当前值是 expectedValue，则测试和设置函数将会将 newValue 赋值给此 QAtomicInteger 并返回 true。如果值 不 相同，此函数不会做任何事情，并返回 false。

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

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

原子测试并设置。

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

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

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

原子测试并设置。

如果此 QAtomicInteger 的当前值是 expectedValue，则测试和设置函数将会将 newValue 赋值给此 QAtomicInteger 并返回 true。如果值 不 相同，此函数不会做任何事情，并返回 false。

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

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

原子测试并设置。

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

此函数使用了释放内存顺序语义，确保在原子操作之后（按程序顺序）运行的内存访问不会重排序。

T QAtomicInteger::operator T() const

尝试以顺序一致内存顺序原子地加载此 QAtomicInteger 的值；如果不能，则使用 "Acquire" 顺序。该值不会被修改，但请注意，没有保证它始终保持不变。

参阅loadRelaxed() 和 loadAcquire。

T QAtomicInteger::operator&=(T value)

原子加并取。

读取此QAtomicInteger的当前值，然后将值与当前值进行按位与操作，返回新值。

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

另请参阅fetchAndAndOrdered。

T QAtomicInteger::operator++()

原子性地预先增加此QAtomicInteger的值。返回此原子的新值。

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

另请参阅ref(), operator++(int), 和 operator--。

T QAtomicInteger::operator++(int)

原子性地后增加此QAtomicInteger的值。返回此原子的旧值。

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

另请参阅ref(), operator++(), 和 operator--(int)。

T QAtomicInteger::operator+=(T value)

原子加并取。

读取此QAtomicInteger的当前值，然后将其与当前值相加，返回新值。

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

另请参阅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+=。

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

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

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

如果可能，使用顺序一致的内存顺序原子性地将其他值存储为此原子类型；如果没有，则使用"发布"顺序。此函数返回对此对象的引用。

另请参阅storeRelaxed() 和 storeRelease。

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