`<atomic>` 函数

标头 <atomic> 提供以下函数：

`atomic_compare_exchange_strong`

执行原子比较和交换操作。

template <class Ty>
inline bool atomic_compare_exchange_strong(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Value) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Exp
指向类型 Ty 的值的指针。

Value
一个 Ty 类型的值。

返回值

如果值相等，则为 true；否则为 false。

注解

此方法使用隐式 memory_order.memory_order_seq_cst 参数执行原子比较和交换操作。有关详细信息，请参阅 atomic_compare_exchange_strong_explicit。

`atomic_compare_exchange_strong_explicit`

执行 atomic compare and exchange 操作。

template <class T>
inline bool atomic_compare_exchange_strong_explicit(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong_explicit(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Exp
指向类型 Ty 的值的指针。

Value
一个 Ty 类型的值。

Order1
第一个 memory_order 参数。

Order2
第二个 memory_order 参数。 Order2 的值不能为 memory_order_release 或 memory_order_acq_rel，它不能比 Order1 的值更强。

返回值

如果值相等，则为 true；否则为 false。

注解

atomic compare and exchange operation 比较 Atom 指向的存储在对象中的值与 Exp 所指向的值。如果这些值相等，将会使用读取-修改-写入操作将 Atom 所指向的存储在对象中的值替换为 Value，并应用 Order1 指定的内存顺序约束。如果这些值不相等，该操作会将 Exp 所指向的值替换为 Atom 所指向的存储在对象中的值，并应用 Order2 指定的内存顺序约束。

`atomic_compare_exchange_weak`

执行弱原子比较和交换操作。

template <class Ty>
inline bool atomic_compare_exchange_strong(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Exp
指向类型 Ty 的值的指针。

Value
一个 Ty 类型的值。

返回值

如果值相等，则为 true；否则为 false。

注解

此方法执行具有隐式参数的memory_order.memory_order_seq_cst操作。有关详细信息，请参阅 atomic_compare_exchange_weak_explicit。

`atomic_compare_exchange_weak_explicit`

执行弱原子比较和交换操作。

template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Exp
指向类型 Ty 的值的指针。

Value
一个 Ty 类型的值。

Order1
第一个 memory_order 参数。

Order2
第二个 memory_order 参数。 Order2 的值不能为 memory_order_release 或 memory_order_acq_rel，也不能比 Order1 的值更强。

返回值

如果值相等，则为 true；否则为 false。

注解

atomic compare and exchange operation 的强弱风格都保证当预期值和当前值不相等时不会存储新值。强风格保证在预期值和当前值相等时存储新值。弱风格有时可能返回 false，并且不存储新值，即使当前值和预期值相等。换句话说，该函数将返回 false，但稍后对预期值的检查可能会显示它没有更改，因此应该将其视为相等。

`atomic_exchange`

使用 Value 替换存储的值 Atom。

template <class T>
inline Ty atomic_exchange(volatile atomic<Ty>* _Atom, Ty Value) noexcept;

template <class Ty>
inline T atomic_exchange(atomic<Ty>* Atom, Ty Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Value
一个 Ty 类型的值。

返回值

交换前 Atom 的存储值。

注解

atomic_exchange 函数执行读取-修改-写入操作，使用 Atom 将存储在 Value 中的值与 memory_order.memory_order_seq_cst 交换。

`atomic_exchange_explicit`

将 Atom 的存储值替换为 Value。

template <class Ty>
inline Ty atomic_exchange_explicit(
    volatile atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

template <class Ty>
inline Ty atomic_exchange_explicit(
    atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

交换前 Atom 的存储值。

注解

atomic_exchange_explicit 函数执行读取-修改-写入操作，在 Atom 指定的内存约束范围内，将存储在 Value 中的值与 Order 交换。

`atomic_fetch_add`

将值添加到 atomic 对象中存储的现有值。

template <class T>
T* atomic_fetch_add(volatile atomic<T*>* Atom, ptrdiff_t Value) noexcept;
template <class T>
T* atomic_fetch_add(atomic<T*>* Atom, ptrdiff_t Value) noexcept;

参数

Atom
一个指向 atomic 对象的指针，该对象存储指向类型 T 的指针。

Value
一个 ptrdiff_t 类型的值。

返回值

执行该操作之前的 atomic 对象包含的指针的值。

注解

atomic_fetch_add 函数执行读取-修改-写入操作，使用 Value 约束以原子方式将 Atom 添加到 memory_order.memory_order_seq_cst 中存储的值。

当原子类型为 atomic_address 时，Value 具有类型 ptrdiff_t，并且操作将存储指针视为 char *。

另外还将为整型类型重载该操作：

integral atomic_fetch_add(volatile atomic-integral* Atom, integral Value) noexcept;

integral atomic_fetch_add(atomic-integral* Atom, integral Value) noexcept;

`atomic_fetch_add_explicit`

将值添加到 atomic 对象中存储的现有值。

template <class T>
T* atomic_fetch_add_explicit(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

template <class T>
T* atomic_fetch_add_explicit(
    atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

参数

Atom
一个指向 atomic 对象的指针，该对象存储指向类型 T 的指针。

Value
一个 ptrdiff_t 类型的值。

返回值

执行该操作之前的 atomic 对象包含的指针的值。

注解

atomic_fetch_add_explicit 函数执行读取-修改-写入操作，在 Value 指定的 Atom 约束范围内，以原子方式将 memory_order 添加到 Order 中存储的值。

当原子类型为 atomic_address 时，Value 具有类型 ptrdiff_t，并且操作将存储指针视为 char *。

另外还将为整型类型重载该操作：

integral atomic_fetch_add_explicit(
    volatile atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

integral atomic_fetch_add_explicit(
    atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

`atomic_fetch_and`

对某个值和存储在 & 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_and 函数执行读取-修改-写入操作，使用 Atom 约束将 & 的存储值替换为 Value 的按位 Atom 和存储在 memory_order.memory_order_seq_cst 中的当前值。

`atomic_fetch_and_explicit`

对某个值和存储在 & 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_and_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_and_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

Order
一个 memory_order。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_and_explicit 函数执行读取-修改-写入操作，以在 Atom 指定的内存约束范围内，将 & 的存储值替换为 Value 的按位 Atom 和存储在 Order 中的当前值。

`atomic_fetch_or`

对某个值和存储在 or 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_or 函数执行读取-修改-写入操作，使用 Atom 将 or 的存储值替换为 Value 的按位 Atom 和存储在 memory_order.memory_order_seq_cst 中的当前值。

`atomic_fetch_or_explicit`

对某个值和存储在 or 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_or_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_or_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

Order
一个 memory_order。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_or_explicit 函数执行读取-修改-写入操作，以在 Atom 指定的 or 约束范围内，将 Value 的存储值替换为 Atom 的按位 memory_order 和存储在 Order 中的当前值。

`atomic_fetch_sub`

从 atomic 对象存储的现有值中减去一个值。

template <class T>
T* atomic_fetch_sub(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value) noexcept;

template <class T>
T* atomic_fetch_sub(
    atomic<T*>* Atom,
    ptrdiff_t Value) noexcept;

参数

Atom
一个指向 atomic 对象的指针，该对象存储指向类型 T 的指针。

Value
一个 ptrdiff_t 类型的值。

返回值

执行该操作之前的 atomic 对象包含的指针的值。

注解

atomic_fetch_sub 函数执行读取-修改-写入操作，使用 Value 约束以原子方式从 Atom 存储的值中减去 memory_order.memory_order_seq_cst。

当原子类型为 atomic_address 时，Value 具有类型 ptrdiff_t，并且操作将存储指针视为 char *。

另外还将为整型类型重载该操作：

integral atomic_fetch_sub(volatile atomic-integral* Atom, integral Value) noexcept;
integral atomic_fetch_sub(atomic-integral* Atom, integral Value) noexcept;

`atomic_fetch_sub_explicit`

从 atomic 对象存储的现有值中减去一个值。

template <class T>
T* atomic_fetch_sub_explicit(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

template <class T>
T* atomic_fetch_sub_explicit(
    atomic<T*>* Atom,
    ptrdiff_t Value, memory_order Order) noexcept;

参数

Atom
一个指向 atomic 对象的指针，该对象存储指向类型 T 的指针。

Value
一个 ptrdiff_t 类型的值。

返回值

执行该操作之前的 atomic 对象包含的指针的值。

注解

atomic_fetch_sub_explicit 函数执行读取-修改-写入操作，以在 Value 指定的 Atom 约束范围内，以原子方式从 memory_order 中存储的值减去 Order。

当原子类型为 atomic_address 时，Value 具有类型 ptrdiff_t，并且操作将存储指针视为 char *。

另外还将为整型类型重载该操作：

integral atomic_fetch_sub_explicit(
    volatile atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

integral atomic_fetch_sub_explicit(
    atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

`atomic_fetch_xor`

对某个值和存储在 exclusive or 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;

template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_xor 函数执行读取-修改-写入操作，使用 Atom 将 exclusive or 的存储值替换为 Value 的按位 Atom 和存储在 memory_order.memory_order_seq_cst 中的当前值。

`atomic_fetch_xor_explicit`

对某个值和存储在 exclusive or 对象中的一个现有值执行按位 atomic。

template <class T>
inline T atomic_fetch_xor_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_xor_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

Value
一个 T 类型的值。

Order
一个 memory_order。

返回值

执行该操作之前的 atomic 对象包含的值。

注解

atomic_fetch_xor_explicit 函数执行读取-修改-写入操作，以在 Atom 指定的 exclusive or 约束范围内，将 Value 的存储值替换为 Atom 的按位 memory_order 和存储在 Order 中的当前值。

`atomic_flag_clear`

在 bool 内，将 atomic_flag 对象中的 false 标志设置为 memory_order.memory_order_seq_cst。

inline void atomic_flag_clear(volatile atomic_flag* Flag) noexcept;
inline void atomic_flag_clear(atomic_flag* Flag) noexcept;

参数

Flag
指向 atomic_flag 对象的指针。

`atomic_flag_clear_explicit`

在指定的 bool 约束内，将 atomic_flag 对象中的 false 标志设置为 memory_order。

inline void atomic_flag_clear_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline void atomic_flag_clear_explicit(atomic_flag* Flag, memory_order Order) noexcept;

参数

Flag
指向 atomic_flag 对象的指针。

Order
一个 memory_order。

`atomic_flag_test_and_set`

在 bool 的约束范围内，将 atomic_flag 对象中的 true 标志设置为 memory_order.memory_order_seq_cst。

inline bool atomic_flag_test_and_set(volatile atomic_flag* Flag) noexcept;
inline bool atomic_flag_test_and_set(atomic_flag* Flag) noexcept;

参数

Flag
指向 atomic_flag 对象的指针。

返回值

Flag 的初始值。

`atomic_flag_test_and_set_explicit`

在指定的 bool 约束内，将 atomic_flag 对象中的 true 标志设置为 memory_order。

inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline bool atomic_flag_test_and_set_explicit(atomic_flag* Flag, memory_order Order) noexcept;

参数

Flag
指向 atomic_flag 对象的指针。

Order
一个 memory_order。

返回值

Flag 的初始值。

`atomic_init`

设置 atomic 对象中存储的值。

template <class Ty>
inline void atomic_init(volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline void atomic_init(atomic<Ty>* Atom, Ty Value) noexcept;

参数

Atom
指向存储类型 atomic 值的 Ty 对象的指针。

Value
一个 Ty 类型的值。

注解

atomic_init 不是一个原子操作。它不是线程安全的。

`atomic_is_lock_free`

指定对 atomic 对象执行的原子操作是否为无锁。

template <class T>
inline bool atomic_is_lock_free(const volatile atomic<T>* Atom) noexcept;
template <class T>
inline bool atomic_is_lock_free(const atomic<T>* Atom) noexcept;

参数

Atom
指向存储类型 atomic 值的 T 对象的指针。

返回值

如果对 true 执行的原子操作为无锁，则返回 Atom；否则，返回 false。

注解

如果对该类型执行的原子操作都没有使用锁，则原子类型为无锁。如果此函数返回 true，则可以安全地在信号处理程序中使用该类型。

`atomic_load`

检索 atomic 对象中存储的值。

template <class Ty>
inline Ty atomic_load(const volatile atomic<Ty>* Atom) noexcept;
template <class Ty>
inline Ty atomic_load(const atomic<Ty>* Atom) noexcept;

参数

Atom
指向包含 atomic 类型值的 Ty 对象的指针。

返回值

存储在 Atom 中的检索到的值。

注解

atomic_load 隐式使用 memory_order.memory_order_seq_cst。

`atomic_load_explicit`

检索 atomic 对象中存储的值（限于指定的 memory_order）。

template <class Ty>
inline Ty atomic_load_explicit(const volatile atomic<Ty>* Atom, memory_order Order) noexcept;
template <class Ty>
inline Ty atomic_load_explicit(const atomic<Ty>* Atom, memory_order Order) noexcept;

参数

Atom
指向包含 atomic 类型值的 Ty 对象的指针。

Order
一个 memory_order。不要使用 memory_order_release 或 memory_order_acq_rel。

返回值

存储在 Atom 中的检索到的值。

`atomic_signal_fence`

充当调用线程中信号处理程序在同一线程中执行的其他 fence 之间的 fence（强制在加载/存储操作之间进行排序的内存同步基元）。

inline void atomic_signal_fence(memory_order Order) noexcept;

参数

Order
确定 fence 类型的内存排序约束。

注解

Order 参数确定 fence 类型。

值	说明
`memory_order_relaxed`	fence 不起作用。
`memory_order_consume`	fence 为 acquire fence。
`memory_order_acquire`	fence 为 acquire fence。
`memory_order_release`	fence 为 release fence。
`memory_order_acq_rel`	fence 既是 acquire fence 也是 release fence。
`memory_order_seq_cst`	fence 既是 acquire fence 也是 release fence，并且在顺序上保持一致。

`atomic_store`

以原子方式将值存储在 atomic 对象中。

template <class Ty>
inline Ty atomic_store_explicit(const volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline Ty atomic_store_explicit(const atomic<Ty>* Atom, T Value) noexcept;

参数

Atom
指向包含 atomic 类型值的 Ty 对象的指针。

Value
一个 Ty 类型的值。

注解

atomic_store 在 Value 约束的范围内，将 Atom 存储在 memory_order.memory_order_seq_cst 所指向的对象中。

`atomic_store_explicit`

以原子方式将值存储在 atomic 对象中。

template <class Ty>
inline Ty atomic_store_explicit(
    const volatile atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

template <class Ty>
inline Ty atomic_store_explicit(
    const atomic<Ty>* Atom,
    T Value,
    memory_order Order) noexcept;

参数

Atom
指向包含 atomic 类型值的 Ty 对象的指针。

Value
一个 Ty 类型的值。

Order
一个 memory_order。请勿使用 memory_order_consume、memory_order_acquire 或 memory_order_acq_rel。

注解

atomic_store 将 Value 存储到 Atom 所指向的对象中（限于 memory_order 指定的 Order）。

`atomic_thread_fence`

充当 fence（强制在加载/存储操作之间进行排序的内存同步基元），没有关联的原子操作。

inline void atomic_thread_fence(memory_order Order) noexcept;

参数

Order
确定 fence 类型的内存排序约束。

注解

Order 参数确定 fence 类型。

值	说明
`memory_order_relaxed`	fence 不起作用。
`memory_order_consume`	fence 为 acquire fence。
`memory_order_acquire`	fence 为 acquire fence。
`memory_order_release`	fence 为 release fence。
`memory_order_acq_rel`	fence 既是 acquire fence 也是 release fence。
`memory_order_seq_cst`	fence 既是 acquire fence 也是 release fence，并且在顺序上保持一致。

`kill_dependency`

删除依赖关系。

template <class Ty>
Ty kill_dependency(Ty Arg) noexcept;

参数

Arg
一个 Ty 类型的值。

返回值

返回值为 Arg。 Arg 的求值不会将依赖关系传送至函数调用。通过中断可能的依赖关系链，该函数可能允许编译器生成更高效的代码。

另请参阅

<atomic>

反馈

此页面是否有帮助？

Last updated on 2025-11-07

通过

<atomic> 函数

atomic_compare_exchange_strong

参数

返回值

注解

atomic_compare_exchange_strong_explicit

参数

返回值

注解

atomic_compare_exchange_weak

参数

返回值

注解

atomic_compare_exchange_weak_explicit

参数

返回值

注解

atomic_exchange

参数

返回值

注解

atomic_exchange_explicit

参数

返回值

注解

atomic_fetch_add

参数

返回值

注解

atomic_fetch_add_explicit

参数

返回值

注解

atomic_fetch_and

参数

返回值

注解

atomic_fetch_and_explicit

参数

返回值

注解

atomic_fetch_or

参数

返回值

注解

atomic_fetch_or_explicit

参数

返回值

注解

atomic_fetch_sub

参数

返回值

注解

atomic_fetch_sub_explicit

参数

返回值

注解

atomic_fetch_xor

参数

返回值

注解

atomic_fetch_xor_explicit

参数

返回值

注解

atomic_flag_clear

参数

atomic_flag_clear_explicit

参数

atomic_flag_test_and_set

参数

返回值

atomic_flag_test_and_set_explicit

参数

返回值

atomic_init

参数

注解

atomic_is_lock_free

`<atomic>` 函数

`atomic_compare_exchange_strong`

`atomic_compare_exchange_strong_explicit`

`atomic_compare_exchange_weak`

`atomic_compare_exchange_weak_explicit`

`atomic_exchange`

`atomic_exchange_explicit`

`atomic_fetch_add`

`atomic_fetch_add_explicit`

`atomic_fetch_and`

`atomic_fetch_and_explicit`

`atomic_fetch_or`

`atomic_fetch_or_explicit`

`atomic_fetch_sub`

`atomic_fetch_sub_explicit`

`atomic_fetch_xor`

`atomic_fetch_xor_explicit`

`atomic_flag_clear`

`atomic_flag_clear_explicit`

`atomic_flag_test_and_set`

`atomic_flag_test_and_set_explicit`

`atomic_init`

`atomic_is_lock_free`

`atomic_load`

`atomic_load_explicit`

`atomic_signal_fence`

`atomic_store`

`atomic_store_explicit`

`atomic_thread_fence`

`kill_dependency`