C++11 并发指南六(atomic 类型详解一 atomic_flag 介绍) 一文介绍了 C++11 中最简单的原子类型 std::atomic_flag，但是 std::atomic_flag 过于简单，只提供了 test_and_set 和 clear 两个 API，不能满足其他需求(如 store, load, exchange, compare_exchange 等)，因此本文将介绍功能更加完善的 std::atomic 类。
std::atomic 基本介绍
std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。
template <class T> struct atomic; 原子类型对象的主要特点就是从不同线程访问不会导致数据竞争(data race)。因此从不同线程访问某个原子对象是良性 (well-defined) 行为，而通常对于非原子类型而言，并发访问某个对象（如果不做任何同步操作）会导致未定义 (undifined) 行为发生。
C++11 标准中的基本 std::atomic 模板定义如下：
template < class T > struct atomic {
bool is_lock_free() const volatile;
bool is_lock_free() const;
void store(T, memory_order = memory_order_seq_cst) volatile;
void store(T, memory_order = memory_order_seq_cst);
T load(memory_order = memory_order_seq_cst) const volatile;
T load(memory_order = memory_order_seq_cst) const;
operator T() const volatile;
operator T() const;
T exchange(T, memory_order = memory_order_seq_cst) volatile;
T exchange(T, memory_order = memory_order_seq_cst);
bool compare_exchange_weak(T &, T, memory_order, memory_order) volatile;
bool compare_exchange_weak(T &, T, memory_order, memory_order);
bool compare_exchange_strong(T &, T, memory_order, memory_order) volatile;
bool compare_exchange_strong(T &, T, memory_order, memory_order);
bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst);
bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst);
atomic() = default;
constexpr atomic(T);
atomic(const atomic &) = delete;
atomic & operator=(const atomic &) = delete;
atomic & operator=(const atomic &) volatile = delete;
T operator=(T) volatile;
T operator=(T);
}; 另外，C++11 标准库 std::atomic 提供了针对整形(integral)和指针类型的特化实现，分别定义如下：
针对整形(integal)的特化，其中 integal 代表了如下类型char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, char16_t, char32_t, wchar_t：
?
|
针对指针的特化：
?
|
std::atomic 成员函数
好了，对 std::atomic 有了一个最基本认识之后我们来看 std::atomic 的成员函数吧。
std::atomic 构造函数
std::atomic 的构造函数如下：
| default (1) | |
|---|---|
| initialization (2) | |
| copy [deleted] (3) | |
- 默认构造函数，由默认构造函数创建的 std::atomic 对象处于未初始化(uninitialized)状态，对处于未初始化(uninitialized)状态 std::atomic对象可以由 atomic_init 函数进行初始化。
- 初始化构造函数，由类型 T初始化一个 std::atomic对象。
- 拷贝构造函数被禁用。
请看下例：
?
|
std::atomic::operator=() 函数
std::atomic 的赋值操作函数定义如下：
| set value (1) | |
|---|---|
| copy [deleted] (2) | |
可以看出，普通的赋值拷贝操作已经被禁用。但是一个类型为 T 的变量可以赋值给相应的原子类型变量（相当与隐式转换），该操作是原子的，内存序(Memory Order) 默认为顺序一致性(std::memory_order_seq_cst)，如果需要指定其他的内存序，需使用 std::atomic::store()。
?
|
基本 std::atomic 类型操作
本节主要介绍基本 std::atomic 类型所具备的操作（即成员函数）。我们知道 std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。本文<std::atomic 基本介绍>一节中也提到了 std::atomic 类模板除了基本类型以外，还针对整形和指针类型做了特化。 特化的 std::atomic 类型支持更多的操作，如 fetch_add, fetch_sub, fetch_and 等。本小节介绍基本 std::atomic 类型所具备的操作：
- is_lock_free
?
|
- 判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞。(可能使用某种事务内存 transactional memory方法实现 lock-free 的特性)。
- store
?
|
- 修改被封装的值，std::atomic::store 函数将类型为 T 的参数 val 复制给原子对象所封装的值。T 是 std::atomic 类模板参数。另外参数 sync 指定内存序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 类型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_release | Release |
| memory_order_seq_cst | Sequentially consistent |
- 请看下面例子：
?
|
- load
?
|
- 读取被封装的值，参数 sync 设置内存序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 类型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_seq_cst | Sequentially consistent |
- 请看下面例子：
?
|
- operator T
?
|
- 与 load 功能类似，也是 读取被封装的值，operator T() 是类型转换( type-cast) 操作，默认的内存序是 std::memory_order_seq_cst，如果需要指定其他的内存序，你应该使用 load() 函数。请看下面例子：
?
|
- exchange
T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept; - 读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。sync参数指定内存序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 类型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
请看下面例子，各个线程计数至 1M，首先完成计数任务的线程打印自己的 ID，
?
|
- compare_exchange_weak
| (1) | |
|---|---|
| (2) | |
- 比较并交换被封装的值(weak)与参数 expected 所指定的值是否相等，如果：
- 相等，则用 val 替换原子对象的旧值。
- 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。
该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。
在第 (2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。
注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。
与 compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允许( spuriously 地)返回 false(即原子对象所封装的值与参数 expected 的物理内容相同，但却仍然返回 false)，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判断确实发生了伪失败( spurious failures)——即使原子对象所封装的值与参数 expected 的物理内容相同，但判断操作的结果却为 false，compare_exchange_weak函数返回 false，并且参数
expected 的值不会改变。
对于某些不需要采用循环操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，该函数的内存序由 sync 参数指定，可选条件如下：
| Memory Order 值 | Memory Order 类型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
- 请看下面的例子（ 参考）：
?
|
- 可能的执行结果如下：
?
|
- compare_exchange_strong
| (1) | |
|---|---|
| (2) | |
- 比较并交换被封装的值(strong)与参数 expected 所指定的值是否相等，如果：
- 相等，则用 val 替换原子对象的旧值。
- 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。
该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。
在第 (2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。
注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。
与 compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允许( spuriously 地)返回 false，即原子对象所封装的值与参数 expected 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， compare_exchange_weak 的性能会更好。
因此对于某些不需要采用循环操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，该函数的内存序由 sync 参数指定，可选条件如下：
| Memory Order 值 | Memory Order 类型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
- 请看下面的例子：
?
|
好了，本文花了大量的篇幅介绍 std::atomic 基本类型，下一篇博客我会给大家介绍 C++11 的标准库中std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。
![C++11之前和C++11之后的 vector 构造函数的区别[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)