c++ 11 原子操作库 （std::atomic）（二）

定义于头文件 <atomic>

atomic 类模板及其针对布尔、整型和指针类型的特化

每个 std::atomic 模板的实例化和全特化定义一个原子类型。若一个线程写入原子对象，同时另一线程从它读取，则行为良好定义（数据竞争的细节见内存模型）。

另外，对原子对象的访问可以建立线程间同步，并按 std::memory_order 所对非原子内存访问定序。

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

构造函数

std::atomic<T>::atomic

atomic() noexcept = default;	(1)	(C++11 起)
constexpr atomic( T desired ) noexcept;	(2)	(C++11 起)
atomic( const atomic& ) = delete;	(3)	(C++11 起)

构造新的原子对象：

1) 默认构造函数是平凡的：不发生静态和线程局域对象的零初始化以外的初始化。 std::atomic_init 可用于完成初始化。

2) 以 desired 初始化底层值。该初始化非原子。

3) 原子对象不可复制构造 (CopyConstructible) 。

参数

desired

-

用以初始化的值

注意

默认初始化的 std::atomic<T> 不含 T 对象，它仅有的合法用法是析构和以 std::atomic_init 初始化，见 LWG 2334 。

存储值于原子对象

std::atomic<T>::operator=

T operator=( T desired ) noexcept;	(1)	(C++11 起)
T operator=( T desired ) volatile noexcept;
atomic& operator=( const atomic& ) = delete;	(2)	(C++11 起)
atomic& operator=( const atomic& ) volatile = delete;

 

1) 原子地赋 desired 给值原子变量。等价于 store(desired) 。

2) 原子变量非可复制赋值 (CopyAssignable) 。

参数

desired

-

要赋值的值

返回值

desired 。

注解

不同于大多数赋值运算符，原子类型的赋值运算符不返回到其左侧参数的引用。它们会返回存储值的副本。

检查原子对象是否免锁

std::atomic<T>::is_lock_free

bool is_lock_free() const noexcept;
bool is_lock_free() const volatile noexcept;

检查此类型所有对象上的原子操作是否免锁。

参数

（无）

返回值

若此类型所有对象上的原子操作免锁则为 true ，否则为 false 。

注意

std::atomic_flag 以外的所有原子类型可用互斥或其他锁定操作实现，而不一定用免锁的原子 CPU 指令。亦允许原子类型有时免锁，例如若给定架构上仅对齐的内存访问是天然原子的，则同类型的错误对齐对象必须用锁。

C++ 标准推荐（但不要求）免锁操作亦为免地址，即适用于使用共享内存的进程间交流。

原子地以非原子对象替换原子对象的值

std::atomic<T>::store

void store( T desired, std::memory_order order = std::memory_order_seq_cst ) noexcept;		(C++11 起)
void store( T desired, std::memory_order order = std::memory_order_seq_cst ) volatile noexcept;

原子地以 desired 替换当前值。按照 order 的值影响内存。

order 必须是 std::memory_order_relaxed 、 std::memory_order_release 或 std::memory_order_seq_cst 之一。否则行为未定义。

参数

desired	-	存储到原子变量中的值
order	-	强制的内存顺序

返回值

（无）

原子地获得原子对象的值

std::atomic<T>::load

T load( std::memory_order order = std::memory_order_seq_cst ) const noexcept;
T load( std::memory_order order = std::memory_order_seq_cst ) const volatile noexcept;

原子地加载并返回原子变量的当前值。按照 order 的值影响内存。

order 必须是 std::memory_order_relaxed 、 std::memory_order_consume 、 std::memory_order_acquire 或 std::memory_order_seq_cst 之一。否则行为未定义。

参数

order

-

强制的内存顺序

返回值

原子变量的当前值。

从原子对象加载值

std::atomic<T>::operator T()

operator T() const noexcept;
operator T() const volatile noexcept;

原子地加载并返回原子变量的当前值。等价于 load() 。

参数

（无）

返回值

原子变量的当前值。

原子地替换原子对象的值并获得它先前持有的值

std::atomic<T>::exchange

T exchange( T desired, std::memory_order order = std::memory_order_seq_cst ) noexcept;
T exchange( T desired, std::memory_order order = std::memory_order_seq_cst ) volatile noexcept;

原子地以 desired 替换底层值。操作为读-修改-写操作。根据 order 的值影响内存。

参数

desired	-	要赋值的值
order	-	要强加的内存顺序制约

返回值

调用前原子对象的值。

原子地比较原子对象与非原子参数的值，若相等则进行交换，若不相等则进行加载

std::atomic<T>::compare_exchange_weak, 
std::atomic<T>::compare_exchange_strong

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order success,
                            std::memory_order failure ) noexcept;   

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order success,
                    std::memory_order failure ) volatile noexcept; (2) (C++11 起) 

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order order =
                            std::memory_order_seq_cst ) noexcept;   

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order order =
                    std::memory_order_seq_cst ) volatile noexcept; (3) (C++11 起) 

bool compare_exchange_strong( T& expected, T desired, 
                              std::memory_order success,
                              std::memory_order failure ) noexcept;   

bool compare_exchange_strong( T& expected, T desired,
                              std::memory_order success,
                    std::memory_order failure ) volatile noexcept;(4) (C++11 起) 

bool compare_exchange_strong( T& expected, T desired,
                              std::memory_order order =
                              std::memory_order_seq_cst ) noexcept;   

bool compare_exchange_strong( T& expected, T desired,
                              std::memory_order order =
                              std::memory_order_seq_cst ) volatile noexcept; 

原子地比较 *this 和 expected 的对象表示 (C++20 前)值表示 (C++20 起)，而若它们逐位相等，则以 desired 替换前者（进行读修改写操作）。否则，将 *this 中的实际值加载进 expected （进行加载操作）。

读修改写和加载操作的内存模型分别为 success 和 failure 。在 (2) 和 (4) 版本中， order 用于读修改写操作和加载操作，除了若 order == std::memory_order_acq_rel 或 order == std::memory_order_release ，则加载操作分别使用 std::memory_order_acquire 和 std::memory_order_relaxed 。

参数

expected	-	到期待在原子对象中找到的值的引用
desired	-	若符合期待则存储于原子对象的值
success	-	若比较成功，则读修改写操作所用的内存同步顺序。容许所有值。
failure	-	若比较失败，则加载操作所用的内存同步顺序。不能为 std::memory_order_release 或 std::memory_order_acq_rel ，且不能指定强于 success 的顺序 (C++17 前)
order	-	两个操作所用的内存同步顺序

返回值

若成功更改底层原子值则为 true ，否则为 false 。

注意

比较和复制是逐位的（类似 std::memcmp 和 std::memcpy ）；不使用构造函数、赋值运算符或比较运算符。

允许函数的弱形式 (1-2) 虚假地失败，即表现如同 *this != expected ，纵使它们相等。比较和交换在循环中时，弱版本在有的平台上会产出更好的性能。

弱版本比较和交换会要求循环，而强版本不要求时，推荐用强版本，除非 T 的对象表示可包含填充位、 (C++20 前)陷阱位或为同一值提供多个对象表示（例如浮点 NaN ）。这些情况下，弱比较和交换典型地可用，因为它在一些稳定对象表示上快速收敛。

若有参与 union 某些成员，但非其他成员的值表示的位，则比较和交换可能始终失败，因为这种填充位在不参与活跃成员的值表示时拥有不确定值。

忽略决不参与对象值表示的填充位。

(C++20 起)

调用 示例

#include <atomic>
#include <iostream>

std::atomic<int>  ai;

int  tst_val = 4;
int  new_val = 5;
bool exchanged = false;

void valsout()
{
    std::cout << "ai= " << ai
              << "  tst_val= " << tst_val
              << "  new_val= " << new_val
              << "  exchanged= " << std::boolalpha << exchanged
              << "\n";
}

int main()
{
    ai = 3;
    valsout();

    // tst_val != ai   ==>  tst_val 被修改
    exchanged = ai.compare_exchange_strong(tst_val, new_val);
    valsout();

    // tst_val == ai   ==>  ai 被修改
    exchanged = ai.compare_exchange_strong(tst_val, new_val);
    valsout();
}