std::atomic 相关接口(来自cppreference.com)-阿里云开发者社区

std::atomic

以下是对 C++ 并发支持库 std::atomic 的概述：

定义在头文件中的模板：

template< class T > struct atomic; (自 C++11 起)
template< class U > struct atomic; (自 C++11 起)

定义在头文件中的模板：

template< class U > struct atomic>; (自 C++20 起)
template< class U > struct atomic>; (自 C++20 起)

定义在头文件中的宏：

#define _Atomic(T) /* see below */ (自 C++23 起)

每个 std::atomic 模板的实例化和完全特化都定义了一个原子类型。如果一个线程向原子对象写入，而另一个线程从中读取，那么行为是良好定义的（参见内存模型以获取有关数据竞争的详细信息）。

此外，对原子对象的访问可能会建立线程间的同步，并按照 std::memory_order 指定的方式对非原子内存访问进行排序。

std::atomic 既不可复制也不可移动。

兼容性宏 _Atomic 在中提供，使得 _Atomic(T) 与 std::atomic 完全相同，只要两者都是良好形成的。

当包含时，是否可以使用命名空间 std 中的任何声明是未指定的。

特化：

主模板：主std::atomic模板可以用任何满足CopyConstructible和CopyAssignable的TriviallyCopyable类型T实例化。如果以下任何值为false，程序将是不良形成的：

std::is_trivially_copyable::value
std::is_copy_constructible::value
std::is_move_constructible::value
std::is_copy_assignable::value
std::is_move_assignable::value

部分特化：标准库为以下类型提供了std::atomic模板的部分特化，这些特化具有主模板不具有的额外属性：

对所有指针类型的部分特化 std::atomic。这些特化具有标准布局，平凡的默认构造函数，并支持适用于指针类型的原子算术操作，如 fetch_add，fetch_sub。
对 std::shared_ptr 和 std::weak_ptr 的部分特化 std::atomic> 和 std::atomic>。

对于整型类型的特化：

当与以下整型类型之一实例化时，std::atomic 提供适用于整型类型的额外

原子操作，如 fetch_add，fetch_sub，fetch_and，fetch_or，fetch_xor：

字符类型 char，char8_t（自 C++20 起），char16_t，char32_t 和 wchar_t；
标准有符号整数类型：signed char，short，int，long 和 long long；
标准无符号整数类型：unsigned char，unsigned short，unsigned int，unsigned long 和 unsigned long long；
头文件中的 typedef 所需的任何额外整数类型。
此外，生成的 std::atomic 特化具有标准布局，平凡的默认构造函数和平凡的析构函数。有符号整数算术被定义为使用二进制补码；没有未定义的结果。

对于浮点类型的特化：

当与 cv-未限定的浮点类型（float，double，long double 和 cv-未限定的扩展浮点类型（自 C++23 起））之一实例化时，std::atomic 提供适用于浮点类型的额外原子操作，如 fetch_add 和 fetch_sub。
此外，生成的 std::atomic 特化具有标准布局和平凡的析构函数。
即使结果在浮点类型中不可表示，也不会有操作导致未定义的行为。有效的浮点环境可能与调用线程的浮点环境不同。

类型别名

类型别名为 bool 和所有上述整数类型提供了如下别名：

对所有 std::atomic 的别名

atomic_bool

(自 C++11 起) std::atomic (typedef)

atomic_char

(自 C++11 起) std::atomic (typedef)

atomic_schar

(自 C++11 起) std::atomic (typedef)

atomic_uchar

(自 C++11 起) std::atomic (typedef)

atomic_short

(自 C++11 起) std::atomic (typedef)

atomic_ushort

(自 C++11 起) std::atomic (typedef)

atomic_int

(自 C++11 起) std::atomic (typedef)

atomic_uint

(自 C++11 起) std::atomic (typedef)

atomic_long

(自 C++11 起) std::atomic (typedef)

atomic_ulong

(自 C++11 起) std::atomic (typedef)

atomic_llong

(自 C++11 起) std::atomic (typedef)

atomic_ullong

(自 C++11 起) std::atomic (typedef)

atomic_char8_t

(自 C++20 起) std::atomic (typedef)

atomic_char16_t

(自 C++11 起) std::atomic (typedef)

atomic_char32_t

(自 C++11 起) std::atomic (typedef)

atomic_wchar_t

(自 C++11 起) std::atomic (typedef)

atomic_int8_t

(自 C++11 起)(可选) std::atomicstd::int8_t (typedef)

atomic_uint8_t

(自 C++11 起)(可选) std::atomicstd::uint8_t (typedef)

atomic_int16_t

(自 C++11 起)(可选) std::atomicstd::int16_t (typedef)

atomic_uint16_t

(自 C++11 起)(可选) std::atomicstd::uint16_t (typedef)

atomic_int32_t

(自 C++11 起)(可选) std::atomicstd::int32_t (typedef)

atomic_uint32_t

(自 C++11 起)(可选) std::atomicstd::uint32_t (typedef)

atomic_int64_t

(自 C++11 起)(可选) std::atomicstd::int64_t (typedef)

atomic_uint64_t

(自 C++11 起)(可选) std::atomicstd::uint64_t (typedef)

atomic_int_least8_t

(自 C++11 起) std::atomicstd::int_least8_t (typedef)

atomic_uint_least8_t

(自 C++11 起) std::atomicstd::uint_least8_t (typedef)

atomic_int_least16_t

(自 C++11 起)

std::atomicstd::int_least16_t (typedef)

atomic_uint_least16_t

(自 C++11 起) std::atomicstd::uint_least16_t (typedef)

atomic_int_least32_t

(自 C++11 起) std::atomicstd::int_least32_t (typedef)

atomic_uint_least32_t

(自 C++11 起) std::atomicstd::uint_least32_t (typedef)

atomic_int_least64_t

(自 C++11 起) std::atomicstd::int_least64_t (typedef)

atomic_uint_least64_t

(自 C++11 起) std::atomicstd::uint_least64_t (typedef)

atomic_int_fast8_t

(自 C++11 起) std::atomicstd::int_fast8_t (typedef)

atomic_uint_fast8_t

(自 C++11 起) std::atomicstd::uint_fast8_t (typedef)

atomic_int_fast16_t

(自 C++11 起) std::atomicstd::int_fast16_t (typedef)

atomic_uint_fast16_t

(自 C++11 起) std::atomicstd::uint_fast16_t (typedef)

atomic_int_fast32_t

(自 C++11 起) std::atomicstd::int_fast32_t (typedef)

atomic_uint_fast32_t

(自 C++11 起) std::atomicstd::uint_fast32_t (typedef)

atomic_int_fast64_t

(自 C++11 起) std::atomicstd::int_fast64_t (typedef)

atomic_uint_fast64_t

(自 C++11 起) std::atomicstd::uint_fast64_t (typedef)

atomic_intptr_t

(自 C++11 起)(可选) std::atomicstd::intptr_t (typedef)

atomic_uintptr_t

(自 C++11 起)(可选) std::atomicstd::uintptr_t (typedef)

atomic_size_t

(自 C++11 起) std::atomicstd::size_t (typedef)

atomic_ptrdiff_t

(自 C++11 起) std::atomicstd::ptrdiff_t (typedef)

atomic_intmax_t

(自 C++11 起) std::atomicstd::intmax_t (typedef)

atomic_uintmax_t

(自 C++11 起) std::atomicstd::uintmax_t (typedef)

特殊用途类型的别名

atomic_signed_lock_free

(自 C++20 起) 一个有符号的整数原子类型，该类型是无锁的，并且等待/通知最有效 (typedef)

atomic_unsigned_lock_free

(自 C++20 起) 一个无符号的整数原子类型，该类型是无锁的，并且等待/通知最有效 (typedef)

注意：std::atomic_intN_t，std::atomic_uintN_t，std::atomic_intptr_t 和 std::atomic_uintptr_t 只有在 std::intN_t，std::uintN_t，std::intptr_t 和 std::uintptr_t 分别定义的情况下才定义。std::

atomic_signed_lock_free 和 std::atomic_unsigned_lock_free 在独立实现中是可选的。

(自 C++20 起)

成员类型_列表

成员类型定义

value_type T (无论是否专门化)

difference_type value_type (仅对 atomic 和 atomic (自 C++20 起) 的专门化)

std::ptrdiff_t (仅对 std::atomic 的专门化)

difference_type 在主 std::atomic 模板或对 std::shared_ptr 和 std::weak_ptr 的部分专门化中未定义。

成员函数_列表

(构造函数)

构造一个原子对象 (公有成员函数)

operator=

将值存储到原子对象中 (公有成员函数)

is_lock_free

检查原子对象是否是无锁的 (公有成员函数)

store

原子地将非原子参数替换为原子对象的值 (公有成员函数)

load

原子地获取原子对象的值 (公有成员函数)

operator T

从原子对象加载值 (公有成员函数)

exchange

原子地替换原子对象的值并获取之前持有的值 (公有成员函数)

compare_exchange_weak

compare_exchange_strong

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载 (公有成员函数)

wait

(自 C++20 起) 阻塞线程，直到通知并且原子值改变 (公有成员函数)

notify_one

(自 C++20 起) 通知至少一个等待原子对象的线程 (公有成员函数)

notify_all

(自 C++20 起) 通知所有阻塞等待原子对象的线程 (公有成员函数)

常量

is_always_lock_free

[静态](自 C++17 起) 表示该类型总是无锁的 (公有静态成员常量)

专门化的成员函数

fetch_add

原子地将参数添加到存储在原子对象中的值，并获取之前持有的值 (公有成员函数)

fetch_sub

原子地从存储在原子对象中的值中减去参数，并获取之前持有的值 (公有成员函数)

fetch_and

原子地执行参数和原子对象的值之间的位与，并获取之前持有的值 (公有成员函数)

fetch_or

原子地执行参数和原子对象的值之间的位或，并获取之前持有的值 (公有成员函数)

fetch_xor

原子地执行参数和原子对象的值之间的位异或，并获取之前持有的值 (公有成员函数)

operator++

operator++(int)

operator–

operator–(int)

将原子值增加

或减少，并返回新值或旧值（公有成员函数）

operator+=

operator-=

operator&=

operator|=

operator^=

将原子值与参数相加、相减、进行位与、位或或位异或，并返回新值（公有成员函数）

非成员函数

atomic_init

初始化原子对象（公有函数模板）

kill_dependency

终止携带依赖性的原子读取（公有函数模板）

atomic_is_lock_free

检查指定的原子类型是否是无锁的（公有函数模板）

atomic_store

原子地将非原子参数替换为原子对象的值（公有函数模板）

atomic_store_explicit

原子地将非原子参数替换为原子对象的值，使用显式内存顺序（公有函数模板）

atomic_load

原子地获取原子对象的值（公有函数模板）

atomic_load_explicit

原子地获取原子对象的值，使用显式内存顺序（公有函数模板）

atomic_exchange

原子地替换原子对象的值并获取之前持有的值（公有函数模板）

atomic_exchange_explicit

原子地替换原子对象的值并获取之前持有的值，使用显式内存顺序（公有函数模板）

atomic_compare_exchange_weak

atomic_compare_exchange_strong

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载（公有函数模板）

atomic_compare_exchange_weak_explicit

atomic_compare_exchange_strong_explicit

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载，使用显式内存顺序（公有函数模板）

atomic_fetch_add

atomic_fetch_sub

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值（公有函数模板）

atomic_fetch_add_explicit

atomic_fetch_sub_explicit

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值，使用显式内存顺序（公有函数模板）

atomic_fetch_and

atomic_fetch_or

atomic_fetch_xor

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值（公有函数模板）

atomic_fetch_and_explicit

atomic_fetch_or_explicit

atomic_fetch_xor_explicit

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值，使用显式内存顺序（公有函数模板）

atomic_flag_test

检查原子标志是否被设置，并将其设置为 true（公有函数模板）

atomic_flag_test_explicit

检查原子标志是否被设置，并将其设置为 true，使用显式内存顺序（公有函数模板）

atomic_flag_test_and_set

原子地设置原子标志并获取之前的值（公有函数模板）

atomic_flag_test_and_set_explicit

原子地设置原子标志并获取之前的值，使用显式内存顺序（公有函数模板）

atomic_flag_clear

原子地清除原子标志（公有函数模板）

atomic_flag_clear_explicit

原子地清除原子标志，使用显式内存顺序（公有函数模板）

std::atomic_ref

提供对非原子对象的原子访问（类模板）

std::atomic_flag

原子布尔类型（类）

std::memory_order

描述了原子操作的内存顺序（枚举）

std::kill_dependency

终止携带依赖性的原子读取（函数模板）

std::atomic_thread_fence

创建一个内存栅栏（函数）

std::atomic_signal_fence

创建一个信号栅栏（函数）

std::atomic_init

初始化原子对象（函数模板）

std::atomic_is_lock_free

检查指定的原子类型是否是无锁的（函数模板）

std::atomic_store

原子地将非原子参数替换为原子对象的值（函数模板）

std::atomic_store_explicit

原子地将非原子参数替换为原子对象的值，使用显式内存顺序（函数模板）

std::atomic_load

原子地获取原子对象的值（函数模板）

std::atomic_load_explicit

原子地获取原子对象的值，使用显式内存顺序（函数模板）

std::atomic_exchange

原子地替换原子对象的值并获取之前持有的值（函数模板）

std::atomic_exchange_explicit

原子地替换原子对象的值并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_compare_exchange_weak

std::atomic_compare_exchange_strong

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载（函数模板）

std::atomic_compare_exchange_weak_explicit

std::atomic_compare_exchange_strong_explicit

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载，使用显式内存顺序（函数模板）

std::atomic_fetch_add

std::atomic_fetch_sub

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值（函数模板）

std::atomic_fetch_add_explicit

std::atomic_fetch_sub_explicit

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_fetch_and

std::atomic_fetch_or

std::atomic_fetch_xor

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值（函数模板）

std::atomic_fetch_and_explicit

std::atomic_fetch_or_explicit

std::atomic_fetch_xor_explicit

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_flag_test

检查原子标志是否被设置，并将其设置为 true（函数模板）

std::atomic_flag_test_explicit

检查原子标志是否被设置，并将其设置为 true，使用显式内存顺序（函数模板）

std::atomic_flag_test_and_set

原子地设置原子标志并获取之前的值（函数模板）

std::atomic_flag_test_and_set_explicit

原子地设置原子标志并获取之前的值，使用显式内存顺序（函数模板）

std::atomic_flag_clear

原子地清除原子标志（函数模板）

std::atomic_flag_clear_explicit

原子地清除原子标志，使用显式内存顺序（函数模板）

std::atomic_ref

提供对非原子对象的原子访问（类模板）

std::atomic_flag

原子布尔类型（类）

std::memory_order

描述了原子操作的内存顺序（枚举）

std::kill_dependency

终止携带依赖性的原子读取（函数模板）

std::atomic_thread_fence

创建一个内存栅栏（函数）

std::atomic_signal_fence

创建一个信号栅栏（函数）

std::atomic_init

初始化原子对象（函数模板）

std::atomic_is_lock_free

检查指定的原子类型是否是无锁的（函数模板）

std::atomic_store

原子地将非原子参数替换为原子对象的值（函数模板）

std::atomic_store_explicit

原子地将非原子参数替换为原子对象的值，使用显式内存顺序（函数模板）

std::atomic_load

原子地获取原子对象的值（函数模板）

std::atomic_load_explicit

原子地获取原子对象的值，使用显式内存顺序（函数模板）

std::atomic_exchange

原子地替换原子对象的值并获取之前持有的值（函数模板）

std::atomic_exchange_explicit

原子地替换原子对象的值并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_compare_exchange_weak

std::atomic_compare_exchange_strong

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载（函数模板）

std::atomic_compare_exchange_weak_explicit

std::atomic_compare_exchange_strong_explicit

原子地将原子对象的值与非原子参数进行比较，如果相等则进行原子交换，如果不等则进行原子加载，使用显式内存顺序（函数模板）

std::atomic_fetch_add

std::atomic_fetch_sub

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值（函数模板）

std::atomic_fetch_add_explicit

std::atomic_fetch_sub_explicit

原子地将参数添加到存储在原子对象中的值或从中减去，并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_fetch_and

std::atomic_fetch_or

std::atomic_fetch_xor

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值（函数模板）

std::atomic_fetch_and_explicit

std::atomic

_fetch_or_explicit

std::atomic_fetch_xor_explicit

原子地执行参数和原子对象的值之间的位与、位或或位异或，并获取之前持有的值，使用显式内存顺序（函数模板）

std::atomic_flag_test

检查原子标志是否被设置，并将其设置为 true（函数模板）

std::atomic_flag_test_explicit

检查原子标志是否被设置，并将其设置为 true，使用显式内存顺序（函数模板）

std::atomic_flag_test_and_set

原子地设置原子标志并获取之前的值（函数模板）

std::atomic_flag_test_and_set_explicit

原子地设置原子标志并获取之前的值，使用显式内存顺序（函数模板）

std::atomic_flag_clear

原子地清除原子标志（函数模板）

std::atomic_flag_clear_explicit

原子地清除原子标志，使用显式内存顺序（函数模板）
以下是您请求的信息，以 Markdown 表格格式呈现：

成员类型_表格

成员类型	定义
value_type	T（无论是否专门化）
difference_type	value_type（仅适用于 atomic 和 atomic（自 C++20 起）的专门化） std::ptrdiff_t（仅适用于 std::atomic<U*> 的专门化）在主 std::atomic 模板或 std::shared_ptr 和 std::weak_ptr 的部分专门化中，未定义 difference_type。

成员函数_表格

成员函数	描述
(constructor)	构造一个原子对象
operator=	将值存储到原子对象中
is_lock_free	检查原子对象是否是无锁的
store	原子地将非原子参数替换为原子对象的值
load	原子地获取原子对象的值
operator T	从原子对象加载值
exchange	原子地替换原子对象的值并获取之前持有的值
compare_exchange_weak compare_exchange_strong	原子地将原子对象的值与非原子参数进行比较，并在相等时执行原子交换，否则执行原子加载
wait (C++20)	阻塞线程，直到通知并且原子值发生变化
notify_one (C++20)	通知至少一个等待原子对象的线程
notify_all (C++20)	通知所有阻塞等待原子对象的线程

常量

常量	描述
is_always_lock_free (C++17)	表示类型始终是无锁的

专门化的成员函数

专门化的成员函数	描述
fetch_add	原子地将参数添加到存储在原子对象中的值，并获取之前持有的值
fetch_sub	原子地从存储在原子对象中的值中减去参数，并获取之前持有的值
fetch_and	原子地执行参数和原子对象的值之间的位与，并获取之前持有的值
fetch_or	原子地执行参数和原子对象的值之间的位或，并获取之前持有的值
fetch_xor	原子地执行参数和原子对象的值之间的位异或，并获取之前持有的值
operator++ operator++(int) operator– operator–(int)	将原子值增加或减少一
operator+= operator-= operator&= operator\|= operator^=	将原子值加、减、执行位与、位或、位异或

说明

std::atomic 的所有成员函数都有非成员函数模板等效项。那些非成员函数可能会对于不是 std::atomic 的专门化，但能够保证原子性的类型进行额外的重载。标准库中唯一的这种类型是 std::shared_ptr。
_Atomic 是 C 中用于提供原子类型的关键字。
实现建议确保 _Atomic(T) 在 C 中的表示与 C++ 中的 std::atomic 对于每一种可能的类型 T 是相同的。用于确保原子性和内存排序的机制应该是兼容的。
在 gcc 和 clang 上，这里描述的一些功能需要链接 -latomic。

示例

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
 
std::atomic_int acnt;
int cnt;
 
void f()
{
    for (int n = 0; n < 10000; ++n)
    {
        ++acnt;
        ++cnt;
        // Note: for this example, relaxed memory order
        // is sufficient, e.g. acnt.fetch_add(1, std::memory_order_relaxed);
    }
}
 
int main()
{
    {
        std::vector<std::jthread> pool;
        for (int n = 0; n < 10; ++n)
            pool.emplace_back(f);
    }
 
    std::cout << "The atomic counter is " << acnt << '\n'
              << "The non-atomic counter is " << cnt << '\n';
}

std::atomic 相关接口(来自cppreference.com)

std::atomic

特化：

对于整型类型的特化：

对于浮点类型的特化：

类型别名

特殊用途类型的别名

成员类型_列表

成员函数_列表

成员类型_表格

成员函数_表格

常量

专门化的成员函数

说明

示例

热门文章

最新文章

相关电子书