C 语言原子操作是在 C11（C11：标准是 C 语言标准的第三版，前一个标准版本是[C99]标准）引入的，定义在头文件 中。C++11 也对原子操作进了封装，定义在头文件中，这里不过多的介绍。Mac 系统里有对原子操作的头文件stdatomic.h，本文的介绍也是基于这个头文件。

1、无锁数据类型

以下宏定义数据类型为无锁数据类型，这些数据类型可以使用标准原子操作函数读取、加载、修改。

  1. #define ATOMIC_BOOL_LOCK_FREE       __CLANG_ATOMIC_BOOL_LOCK_FREE
  2. #define ATOMIC_CHAR_LOCK_FREE       __CLANG_ATOMIC_CHAR_LOCK_FREE
  3. #define ATOMIC_CHAR16_T_LOCK_FREE   __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
  4. #define ATOMIC_CHAR32_T_LOCK_FREE   __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
  5. #define ATOMIC_WCHAR_T_LOCK_FREE    __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
  6. #define ATOMIC_SHORT_LOCK_FREE      __CLANG_ATOMIC_SHORT_LOCK_FREE
  7. #define ATOMIC_INT_LOCK_FREE        __CLANG_ATOMIC_INT_LOCK_FREE
  8. #define ATOMIC_LONG_LOCK_FREE       __CLANG_ATOMIC_LONG_LOCK_FREE
  9. #define ATOMIC_LLONG_LOCK_FREE      __CLANG_ATOMIC_LLONG_LOCK_FREE
  10. #define ATOMIC_POINTER_LOCK_FREE    __CLANG_ATOMIC_POINTER_LOCK_FREE 
  12. _Bool atomic_is_lock_free( const volatile A* obj );

使用atomic_is_lock_free判断原子对子对象是否是无锁的，如果对象的所有数据类型都支持原子操作返回true。

  1. #include <iostream>
  2. #include <stdatomic.h>
  4. int main(int argc, const char * argv[]) {
  5.     atomic_uint _atomic_int;
  6.     atomic_init(&_atomic_int, 1);
  7.     uint32_t _a_int = 0;
  9.     std::cout<<atomic_is_lock_free(&_atomic_int)<<std::endl;
  10.     std::cout<<atomic_is_lock_free(&_a_int)<<std::endl;
  11.     return 0;
  12. }

2、原子操作的数据类型

以下数据类型为标准中定义的支持原子操作的数据类型：

  1. #ifdef __cplusplus
  2. typedef _Atomic(bool)               atomic_bool;
  3. #else
  4. typedef _Atomic(_Bool)              atomic_bool;
  5. #endif
  6. typedef _Atomic(char)               atomic_char;
  7. typedef _Atomic(signed char)        atomic_schar;
  8. typedef _Atomic(unsigned char)      atomic_uchar;
  9. typedef _Atomic(short)              atomic_short;
  10. typedef _Atomic(unsigned short)     atomic_ushort;
  11. typedef _Atomic(int)                atomic_int;
  12. typedef _Atomic(unsigned int)       atomic_uint;
  13. typedef _Atomic(long)               atomic_long;
  14. typedef _Atomic(unsigned long)      atomic_ulong;
  15. typedef _Atomic(long long)          atomic_llong;
  16. typedef _Atomic(unsigned long long) atomic_ullong;
  17. typedef _Atomic(uint_least16_t)     atomic_char16_t;
  18. typedef _Atomic(uint_least32_t)     atomic_char32_t;
  19. typedef _Atomic(wchar_t)            atomic_wchar_t;
  20. typedef _Atomic(int_least8_t)       atomic_int_least8_t;
  21. typedef _Atomic(uint_least8_t)      atomic_uint_least8_t;
  22. typedef _Atomic(int_least16_t)      atomic_int_least16_t;
  23. typedef _Atomic(uint_least16_t)     atomic_uint_least16_t;
  24. typedef _Atomic(int_least32_t)      atomic_int_least32_t;
  25. typedef _Atomic(uint_least32_t)     atomic_uint_least32_t;
  26. typedef _Atomic(int_least64_t)      atomic_int_least64_t;
  27. typedef _Atomic(uint_least64_t)     atomic_uint_least64_t;
  28. typedef _Atomic(int_fast8_t)        atomic_int_fast8_t;
  29. typedef _Atomic(uint_fast8_t)       atomic_uint_fast8_t;
  30. typedef _Atomic(int_fast16_t)       atomic_int_fast16_t;
  31. typedef _Atomic(uint_fast16_t)      atomic_uint_fast16_t;
  32. typedef _Atomic(int_fast32_t)       atomic_int_fast32_t;
  33. typedef _Atomic(uint_fast32_t)      atomic_uint_fast32_t;
  34. typedef _Atomic(int_fast64_t)       atomic_int_fast64_t;
  35. typedef _Atomic(uint_fast64_t)      atomic_uint_fast64_t;
  36. typedef _Atomic(intptr_t)           atomic_intptr_t;
  37. typedef _Atomic(uintptr_t)          atomic_uintptr_t;
  38. typedef _Atomic(size_t)             atomic_size_t;
  39. typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
  40. typedef _Atomic(intmax_t)           atomic_intmax_t;
  41. typedef _Atomic(uintmax_t)          atomic_uintmax_t; 
  43. #define ATOMIC_VAR_INIT(value) (value) 
  44. #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);

  1.  void atomic_init( volatile A* obj, C desired );

3、读取、写入操作

写入（Store operation）

  1. void atomic_store( volatile A* obj , C desired);
  2. 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 ）

  1. C atomic_load( const volatile A* obj );
  2. 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）

原子交换

  1. C atomic_exchange( volatile A* obj, C desired );
  2. C atomic_exchange_explicit( volatile A* obj, C desired, memory_order order );

atomic_exchange和atomic_exchange_explicit：是原子交换操作，将 desired 的值写入到原子对象，并返回之前保存的旧值。
obj：原子对象的指针。
desired：期望交换的新值。
order：内存模型，所有的内存模型都可以。

原子比较交换

  1. _Bool atomic_compare_exchange_strong( volatile A* obj, C* expected, C desired );
  2. _Bool atomic_compare_exchange_weak( volatile A *obj, C* expected, C desired );
  3. _Bool atomic_compare_exchange_strong_explicit( volatile A* obj, C* expected, C desired, memory_order succ, memory_order fail);
  4. _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版本不需要。

原子的加、减、或、异或、并

  1. C atomic_fetch_add( volatile A* obj, M arg );
  2. C atomic_fetch_add_explicit( volatile A* obj, M arg, memory_order order ); 
  4. C atomic_fetch_sub( volatile A* obj, M arg );
  5. C atomic_fetch_sub_explicit( volatile A* obj, M arg, memory_order order ); 
  7. C atomic_fetch_or( volatile A* obj, M arg );
  8. C atomic_fetch_or_explicit( volatile A* obj, M arg, memory_order order ); 
  10. C atomic_fetch_xor( volatile A* obj, M arg );
  11. C atomic_fetch_xor_explicit( volatile A* obj, M arg, memory_order order ); 
  13. C atomic_fetch_and( volatile A* obj, M arg );
  14. C atomic_fetch_and_explicit( volatile A* obj, M arg, memory_order order );

obj：原子对象的指针。
arg：要加上、减上、或上、异或上、并上的值。
order：内存模型，所有的内存模型都可以。

5、原子标记（atomic_flag）

atomic_flag：无锁原子布尔类型。

以下代码初始化atomic_flag类型变量。

  1. #include <stdatomic.h>
  2. atomic_flag flag = ATOMIC_FLAG_INIT; 
  4. _Bool atomic_flag_test_and_set( volatile atomic_flag* obj );
  5. _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，并返回原理的标记值。

  1. void atomic_flag_clear( volatile atomic_flag* obj );
  2. void atomic_flag_clear_explicit( volatile atomic_flag* obj, memory_order order );

atomic_flag_clear和atomic_flag_clear_explicit：原子的将标记值设置为 false。

6、内存屏障

  1. 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 指令执行期间。

  1. int a = 1;
  2. int b = 2;

上面的代码经过编译器重排后可能出现：先初始化b，再初始化a的情况。即使编译器重排后指令是按照代码书写顺序排列的，在运行期间CPU也可能出现重排现象：先初始化b，在初始化a。

为了提高计算机资源利用率和性能，编译器会对代码进行重排， CPU 也会对指令进行重新排序、延缓执行、各种缓存等等，以达到更好的执行效果。当然，任何排序都不能违背代码本身所表达的意义，在单线程情况下，这些优化通常不会有任何问题。

但是在多线程环境下，比如无锁（lock-free）数据结构的设计中，指令的乱序执行会造成无法预测的行为。所以我们引入了内存栅栏（Memory Barrier）这一概念来解决可能存在的并发问题。

内存栅栏 (Memory Barrier)

内存栅栏是一个令 CPU 或编译器在内存操作上限制内存操作顺序的指令，通常意味着Barrier 之前的指令一定在在 Barrier 之后的指令之前执行。

C11 以枚举的方式定义了如下内存顺序：

  1. enum memory_order {
  2.     memory_order_relaxed,
  3.     memory_order_consume,
  4.     memory_order_acquire,
  5.     memory_order_release,
  6.     memory_order_acq_rel,
  7.     memory_order_seq_cst
  8. };

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. C11 中的内存模型下篇 - C11 支持的几种内存模型
4. 如何理解 C11 的六种 memory order
5. C memory order 循序渐进（四）—— 在 std::atomic_thread_fence 上应用 std::memory_order 实现不同的内存序

原文：