简介
用atomic定义的变量，支持原子操作，即要么全部完成操作，要不全部没有完成，我们是不可能看到中间状态。一般在多线程程序中，可以用atomic来完成数据同步。
标准库为我们主要提供了四类工具
- atomic类模板
- 操作atomic的全局方法
- atomic_flag
- 内存顺序，即约束了当前atomic对象前后代码直行的相对顺序
atomic_flag是保证无锁的，任何平台都可以放心使用；atomic 对于整型，浮点类型，提供的方法会略有不同；内存顺序是在操作原子对象的时候，可以施加影响
atomic_flag
atomic_flag相当于是一个原子的bool类型，与atomic的不同点，除了无锁之外，atomic_flag提供的方法也是比较有限的，没有load和store方法：
构造了方法，atomic_flag有默认构造方法，但是直到C++20，默认构造时才会将状态置为false，在此之前为定义状态。所以在C++20之前都是这么定义atomic_flag的
std::atomic_flag automatic_flag = ATOMIC_FLAG_INIT; // false
test_and_set 将atomic_flag设置true，并返回之前的值，可能是true，也可能是false
bool test_and_set( std::memory_order order = std::memory_order_seq_cst ) volatile noexcept; // order是内存顺序，后面会写
bool test_and_set( std::memory_order order = std::memory_order_seq_cst ) noexcept;
用atomic_flag实现自旋锁是一个经典用法
#include <atomic>class Spinlock
{
public:spinlock_mutex():m_flag(ATOMIC_FLAG_INIT) {}void lock() {while(flag.test_and_set()); // 不断重试，直到test_and_set返回false。测试m_flag}void unlock() {flag.clear(std::memory_order_release);}
private:std::atomic_flag m_flag;
};
std::atomic
atomic对于不同的类型支持的方法不一样，任何类型都有的方法如下：
构造方法
atomic() noexcept = default;
constexpr atomic( T desired ) noexcept; // 将atomic初值设置为desired，**但这个过程不是原子的**
atomic( const atomic& ) = delete;
atomic的拷贝赋值操作和普通类的不一样，他的返回值不是引用，而是拷贝。如果返回了引用就无法保证原则操作了。另外，等号右边的是T类型，而不是atomic类型。
T operator=( T desired ) noexcept;
T operator=( T desired ) volatile noexcept;
atomic& operator=( const atomic& ) = delete;
atomic& operator=( const atomic& ) volatile = delete;
检查atomic的当前实现是否为无锁方式。如果是，则atomic原子操作是cpu指令级，否则就是通过锁实现的原子操作，可能用的就是：std::mutex
bool is_lock_free() const noexcept;
bool is_lock_free() const volatile noexcept;
向atomic中写值，为原子操作
void store( T desired, std::memory_order order = std::memory_order_seq_cst ) noexcept;
void store( T desired, std::memory_order order = std::memory_order_seq_cst ) volatile noexcept;
从atomic中读取值，为原子操作。返回值为atomic中保存值的拷贝
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;
隐式转换，等价于load()
operator T() const noexcept;
operator T() const volatile noexcept;
读改写当前变量，返回值是读到的之前的值，改是指对atomic中管理值的修改（瞎猜的：会不会是写缓存，后面研究一下 ），写是指写内存。
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;
比较修改当前变量
如果*this == expected, *this = desired，return true
否则 expected = *this, return false
bool compare_exchange_weak( 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 ) noexcept;
weak版本的CAS允许偶然出乎意料的返回（比如在字段值和期待值一样的时候却返回了false），不过在一些循环算法中，这是可以接受的。通常它比起strong有更高的性能。
atomic对整型支持的最好的，提供的方法也是最多的，还提供了很多typedef的别名，类似这样
对于整型atomic提供的额外方法有：
加法会返回之前的值
T fetch_add( T arg, std::memory_order order = std::memory_order_seq_cst ) noexcept;
加法也会返回之前的值
T fetch_sub( T arg, std::memory_order order = std::memory_order_seq_cst ) noexcept;
按位与，或，异或，也都会返回之前的值
如果atomic的类型为T*，那么直行加，减方法的时候，会返回T*
如果使用自定义类型去作为atomic的模板参数，需要这个自定义类型是可平凡复制的（TriviallyCopyable ），即下面对象的value都必须为true
std::is_trivially_copyable<T>::value
std::is_copy_constructible<T>::value
std::is_move_constructible<T>::value
std::is_copy_assignable<T>::value
std::is_move_assignable<T>::value
简单来说，可平凡复制类型表示这个类型的对象可以直接进行内存拷贝，而不需要执行特殊的拷贝构造函数或者析构函数。换句话说，可平凡复制类型的对象可以拷贝到char或者unsigned char数组中，可以通过std::memcpy or std::memmove操作。一个可平凡复制类型通常具有简单的内存布局，没有虚拟函数或者虚拟基类，并且其拷贝构造函数和析构函数是默认生成的。这意味着这种类型的对象可以更高效地进行拷贝和赋值操作。像标量类型（算术类型/枚举/指针），标量类型作为成员变量构成的类，以及相应数组和cv-qualified修饰的，都是平凡复制类型。
这里有一些例子：https://www.cnblogs.com/BuzzWeek/p/17578402.html
cv-qualified
CV分别是const 以及volatile的缩写。
用const，volatile以及const volatile之一作修饰的变量被成为cv-qualified ，否则该变量是cv-unqualified
内存顺序 std::memory_order
在atomic的很多方法中都有一个参数为std::memory_order类型，不过一般都有默认值（memory_order_seq_cst）。现代C++编译器为了进一步提高代码运行效率，在编译的时候，可能会改变代码的直行顺序，当然是在不改变原有代码逻辑的情况下。比如下面例子，不管那种顺序直行代码，都不影响最终结果。但改变顺序后，可能直行效率会更高一些。std::memory_order正是用来告诉编译器，要不要做这种优化，当然C++中定义会更加详细一些。
int a = 1;
int b = 2;
int c = a;
---
int b = 2;
int a = 1;
int c = a;
std::memory_order的定义如下
typedef enum memory_order {memory_order_relaxed,memory_order_consume,memory_order_acquire,memory_order_release,memory_order_acq_rel,memory_order_seq_cst
} memory_order;
| 枚举值 | 含义 |
|---|---|
| memory_order_relaxed | 允许编译器为了效率可以任意优化执行顺序 |
| memory_order_consume | 如果后续有关于当前原子变量的操作，必须在本条原子操作完成之后直行 |
| memory_order_acquire | 所有后续的读操作必须在本条原子操作完成后直行 |
| memory_order_release | 所有之前的写操作完成后才能执行本条原子操作 |
| memory_order_acq_rel | memory_order_acquire 和 memory_order_release 的组合 |
| memory_order_seq_cst | 全部存取都按顺序执行，不允许编译器优化直行顺序 |
比如使用 memory_order_consume
atomic＜int*＞ ptr;
atomic＜int＞ data;{int* p2;while(!(p2=ptr.load(memory_order_consume)));assert(*p2=="Hello"); // 这一行一定在while之后int d = 5; // 这一行可能在int* 2之前直行，也可能在while之前，总之由于他不依赖ptr，所以就有可能被编译器优化执行顺序
}
再比如 memory_order_acquire
atomic＜int＞ a;
atomic＜int＞ b;{while(b.load(memory_order_acquire)!=2);//本原子操作必须完成才能执行之后所有的读原子操作, 即a.load一定在本条语句之后std::cout ＜＜ a.load(memory_order_relaxed) ＜＜ std::endl;
}
其他的基本类似
前面提到std::memory_order一般是作为atomic相关的方法的一个参数。那么如果想脱离atomic使用std::memory_order，C++提供了std::atomic_thread_fence
extern "C" void atomic_thread_fence( std::memory_order order ) noexcept;
一个官方的例子
// Global
std::string computation(int);
void print(std::string);std::atomic<int> arr[3] = {-1, -1, -1};
std::string data[1000]; //non-atomic data// Thread A, compute 3 values.
void ThreadA(int v0, int v1, int v2)
{
// assert(0 <= v0, v1, v2 < 1000);data[v0] = computation(v0);data[v1] = computation(v1);data[v2] = computation(v2);std::atomic_thread_fence(std::memory_order_release);std::atomic_store_explicit(&arr[0], v0, std::memory_order_relaxed);std::atomic_store_explicit(&arr[1], v1, std::memory_order_relaxed);std::atomic_store_explicit(&arr[2], v2, std::memory_order_relaxed);
}// Thread B, prints between 0 and 3 values already computed.
void ThreadB()
{int v0 = std::atomic_load_explicit(&arr[0], std::memory_order_relaxed);int v1 = std::atomic_load_explicit(&arr[1], std::memory_order_relaxed);int v2 = std::atomic_load_explicit(&arr[2], std::memory_order_relaxed);std::atomic_thread_fence(std::memory_order_acquire);
// v0, v1, v2 might turn out to be -1, some or all of them.
// Otherwise it is safe to read the non-atomic data because of the fences:if (v0 != -1)print(data[v0]);if (v1 != -1)print(data[v1]);if (v2 != -1)print(data[v2]);
}
操作atomic的全局方法
功能和atomic的成员方法一样，命名风格基本都是 atomic_xxx
