C语言原子操作是在C11（C11：标准是C语言标准的第三版，前一个标准版本是[C99]标准）引入的，定义在头文件
1、无锁数据类型
以下宏定义数据类型为无锁数据类型，这些数据类型可以使用标准原子操作函数读取、加载、修改。
#define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE
#define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE
#define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
#define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
#define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
_Bool atomic_is_lock_free( const volatile A* obj );
使用atomic_is_lock_free判断原子对子对象是否是无锁的，如果对象的所有数据类型都支持原子操作返回true。
#include
#include
int main(int argc, const char * argv[]) {
atomic_uint _atomic_int;
atomic_init(&_atomic_int, 1);
uint32_t _a_int = 0;
std::cout< 2、原子操作的数据类型
以下数据类型为标准中定义的支持原子操作的数据类型：
#ifdef __cplusplus
typedef _Atomic(bool) atomic_bool;
#else
typedef _Atomic(_Bool) atomic_bool;
#endif
typedef _Atomic(char) atomic_char;
typedef _Atomic(signed char) atomic_schar;
typedef _Atomic(unsigned char) atomic_uchar;
typedef _Atomic(short) atomic_short;
typedef _Atomic(unsigned short) atomic_ushort;
typedef _Atomic(int) atomic_int;
typedef _Atomic(unsigned int) atomic_uint;
typedef _Atomic(long) atomic_long;
typedef _Atomic(unsigned long) atomic_ulong;
typedef _Atomic(long long) atomic_llong;
typedef _Atomic(unsigned long long) atomic_ullong;
typedef _Atomic(uint_least16_t) atomic_char16_t;
typedef _Atomic(uint_least32_t) atomic_char32_t;
typedef _Atomic(wchar_t) atomic_wchar_t;
typedef _Atomic(int_least8_t) atomic_int_least8_t;
typedef _Atomic(uint_least8_t) atomic_uint_least8_t;
typedef _Atomic(int_least16_t) atomic_int_least16_t;
typedef _Atomic(uint_least16_t) atomic_uint_least16_t;
typedef _Atomic(int_least32_t) atomic_int_least32_t;
typedef _Atomic(uint_least32_t) atomic_uint_least32_t;
typedef _Atomic(int_least64_t) atomic_int_least64_t;
typedef _Atomic(uint_least64_t) atomic_uint_least64_t;
typedef _Atomic(int_fast8_t) atomic_int_fast8_t;
typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t;
typedef _Atomic(int_fast16_t) atomic_int_fast16_t;
typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t;
typedef _Atomic(int_fast32_t) atomic_int_fast32_t;
typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t;
typedef _Atomic(int_fast64_t) atomic_int_fast64_t;
typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t;
typedef _Atomic(intptr_t) atomic_intptr_t;
typedef _Atomic(uintptr_t) atomic_uintptr_t;
typedef _Atomic(size_t) atomic_size_t;
typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
typedef _Atomic(intmax_t) atomic_intmax_t;
typedef _Atomic(uintmax_t) atomic_uintmax_t;
#define ATOMIC_VAR_INIT(value) (value)
#define atomic_init __c11_atomic_init
ATOMIC_VAR_INIT用来初始化一个新的原子对象，atomic_bool flag = ATOMIC_VAR_INIT(1); ATOMIC_VAR_INIT已在C17中被声明为Deprecated，不建议使用。
atomic_init ： 用来初始化一个存在的原子对象 fatomic_init(&flag, 0);
// obj： 原子对象的指针
// desired： 给定的原子对象的初始值
void atomic_init( volatile A* obj, C desired );
3、读取、写入操作
写入（Store operation）
void atomic_store( volatile A* obj , C desired);
void atomic_store_explicit( volatile A* obj, C desired, memory_order order);
atomic_store和atomic_store_explicit：是原子写入操作，将原子对象的值更换为desired的值。
obj：原子对象的指针。
desired：期望写入的值。
order：内存模型。atomic_store带有缺省的内存模型是：memory_order_seq_cst，atomic_store_explicit可使用的内存模型有：memory_order_relaxed，memory_order_release，memory_order_seq_cst。
读取（Load operation ）
C atomic_load( const volatile A* obj );
C atomic_load_explicit( const volatile A* obj, memory_order order);
atomic_load和atomic_load_explicit：是原子读取操作，返回原子对象的值。
obj：原子对象的指针。
order：内存模型。atomic_load带有缺省的内存模型是：memory_order_seq_cst；可使用的内存模型有：memory_order_relaxed，memory_order_acquire，memory_order_consume，memory_order_seq_cst*。
4、读取-修改-写入操作（read-modify-write operation）
原子交换
C atomic_exchange( volatile A* obj, C desired );
C atomic_exchange_explicit( volatile A* obj, C desired, memory_order order );
atomic_exchange和atomic_exchange_explicit：是原子交换操作，将desired的值写入到原子对象，并返回之前保存的旧值。
obj：原子对象的指针。
desired：期望交换的新值。
order：内存模型，所有的内存模型都可以。
原子比较交换
_Bool atomic_compare_exchange_strong( volatile A* obj, C* expected, C desired );
_Bool atomic_compare_exchange_weak( volatile A *obj, C* expected, C desired );
_Bool atomic_compare_exchange_strong_explicit( volatile A* obj, C* expected, C desired, memory_order succ, memory_order fail);
_Bool atomic_compare_exchange_weak_explicit( volatile A *obj, C* expected, C desired, memory_order succ, memory_order fail);
atomic_compare_exchange：比较原子对象*obj和*expected对象，如果相等将desired的值写入原子对象obj并返回true；否则将原子对象的值取出，然后写入到expected，并返回false。
obj：原子对象的指针。
expected：要比较对象的指针。
desired：比较不相等，期望写入的新值。
succ：比较相等时的read-modify-write内存模型，所有的内存模型都可以。
fail：指定比较不相等时的load操作的内存模型，可使用的内存模型有：memory_order_relaxed，memory_order_acquire，memory_order_consume，memory_order_seq_cst。
以weak修饰的版本允许出现虚假的失败（Fail Spuriously），在循环中weak修饰的比较-交换操作可能在出现*obj != *expected的情况（其实它们相等），weak修饰的版本可能在某些平台上拥有更好的性能。weak版本可能需要一个循环，但是strong版本不需要。
原子的加、减、或、异或、并
// 原子加 *obj +=arg;
C atomic_fetch_add( volatile A* obj, M arg );
C atomic_fetch_add_explicit( volatile A* obj, M arg, memory_order order );
// 原子减 *obj -=arg;
C atomic_fetch_sub( volatile A* obj, M arg );
C atomic_fetch_sub_explicit( volatile A* obj, M arg, memory_order order );
// 原子或 *obj |=arg;
C atomic_fetch_or( volatile A* obj, M arg );
C atomic_fetch_or_explicit( volatile A* obj, M arg, memory_order order );
// 原子异或 *obj ^=arg;
C atomic_fetch_xor( volatile A* obj, M arg );
C atomic_fetch_xor_explicit( volatile A* obj, M arg, memory_order order );
// 原子并 *obj &=arg;
C atomic_fetch_and( volatile A* obj, M arg );
C atomic_fetch_and_explicit( volatile A* obj, M arg, memory_order order );
obj：原子对象的指针。
arg：要加上、减上、或上、异或上、并上的值。
order：内存模型，所有的内存模型都可以。
5、原子标记（atomic_flag）
atomic_flag：无锁原子布尔类型。
以下代码初始化atomic_flag类型变量。
#include
atomic_flag flag = ATOMIC_FLAG_INIT; // #define ATOMIC_FLAG_INIT /* unspecified */
_Bool atomic_flag_test_and_set( volatile atomic_flag* obj );
_Bool atomic_flag_test_and_set_explicit( volatile atomic_flag* obj, memory_order order );
atomic_flag_test_and_set和atomic_flag_test_and_set_explicit：原子的设置标记值为true，并返回原理的标记值。
void atomic_flag_clear( volatile atomic_flag* obj );
void atomic_flag_clear_explicit( volatile atomic_flag* obj, memory_order order );
atomic_flag_clear和atomic_flag_clear_explicit：原子的将标记值设置为false。
6、内存屏障
void atomic_thread_fence( memory_order order );
atomic_thread_fence用来创建多线程内存屏障，和使用原子对象的同步语义作用一样，但是不需要原子对象。
order：内存顺序，所有标记都可以。
- atomic_thread_fence(memory_order_relaxed)：这个没有作用
- atomic_thread_fence(memory_order_acquire) 和 atomic_thread_fence(memory_order_consume) ：内存读（acquire）屏障。
- atomic_thread_fence(memory_order_release) ：内存写（release）屏障。
- atomic_thread_fence(memory_order_acq_rel)： 既是读屏障 也是写屏障，也可以叫做完全内存屏障（full memory fence），保障了早于屏障的内存读写操作的结果提交到内存之后，再执行晚于屏障的读写操作。。
- atomic_thread_fence(memory_order_seq_cst) ：保证完全顺序一致性的完全内存屏障，约束最强。
7、内存顺序（Memory Order）
内存顺序指定CPU 读取内存数据的顺序，内存的排序可能发生在编译器编译期间，也可能发生在 CPU 指令执行期间。
int a = 1; int b = 2;上面的代码经过编译器重排后可能出现：先初始化b，再初始化a的情况。即使编译器重排后指令是按照代码书写顺序排列的，在运行期间CPU也可能出现重排现象：先初始化b，在初始化a。
为了提高计算机资源利用率和性能，编译器会对代码进行重排， CPU 也会对指令进行重新排序、延缓执行、各种缓存等等，以达到更好的执行效果。当然，任何排序都不能违背代码本身所表达的意义，在单线程情况下，这些优化通常不会有任何问题。
但是在多线程环境下，比如无锁（lock-free）数据结构的设计中，指令的乱序执行会造成无法预测的行为。所以我们引入了内存栅栏（Memory Barrier）这一概念来解决可能存在的并发问题。
内存栅栏 (Memory Barrier)
内存栅栏是一个令 CPU 或编译器在内存操作上限制内存操作顺序的指令，通常意味着Barrier 之前的指令一定在在 Barrier 之后的指令之前执行。
C11以枚举的方式定义了如下内存顺序：
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_relaxed：只保证当前操作的原子性，没有同步语义，不考虑线程间的同步，对其他线程的读写没有顺序约束，其他线程可能读到新值，也可能读到旧值；同一线程内执行指令的顺序可能不同。
memory_order_release： 修饰写入操作（store），表示在本线程中，在这个语句前的读写操作不能重排到这个语句的后面。当前线程的所有写入操作对其他线程就是可见的，表示当前线程对非局部变量的写入，其他线程都是可以获取到的。
memory_order_acquire：修饰读取操作（load），表示在本线程中，在这个语句后的读写操作不能重排到这个语句的前面。所有其他线程的写入操作，对本线程是可见的。
Release-Acquire ordering：memory_order_release和memory_order_acquire往往是配对使用。如果线程A针对一个原子对象进行memory_order_release的store操作，线程B针对这个原子对象进行memory_order_acquire的load操作，那么线程A中发生在store之前的所有的内存写入（relaxed原子的或者非原子的），都是对线程B执行load后可见的。
这种同步是建立在不同线程针对同一个原子对象做 releasing store和 acquiring load操作之上的。
memory_order_consume：修饰读取操作（load），表示在本线程中，在这个语句后并且依赖这个原子变量的读写操作不能重排到load这个语句的前面。所有其他线程被使用来完成store操作的变量内存的写入，对本线程是可见的。
memory_order_consume比memory_order_acquire约束更小，只影响和这个原子对象相关的内存读写重排。
memory_order_acq_rel：修饰读取-修改-写入操作，表示该操作既是一个acquire操作也是一个release操作。在当前线程中，写入操作的前后内存读写都不可以重排。其他所有线程针对该原子对象的release操作的内存写入，在本线程改变修改操作之前是可见的；对于内存的修改，其他线程在acquire该原子对象前是可见的。
memory_order_seq_cst：这个是memory_order_release，memory_order_acquire和memory_order_acq_rel的综合，约束更强。
读取就是 acquire 语义，如果是写入就是 release 语义，如果是读取+写入就是 acquire-release 语义。
同时会对所有使用此 memory order 的原子操作进行同步，所有线程看到的内存操作的顺序都是一样的，就像单个线程在执行所有线程的指令一样。
本文参考链接：
1. Atomic operations library
2. 内存顺序（Memory Order）
3. C++11中的内存模型下篇 - C++11支持的几种内存模型
4. 如何理解 C++11 的六种 memory order
5. C++ memory order循序渐进（四）—— 在std::atomic_thread_fence 上应用std::memory_order实现不同的内存序