C语言原子操作是在C11(C11:标准是C语言标准的第三版,前一个标准版本是[C99]标准)引入的,定义在头文件 <stdatomic.h>中。C++11也对原子操作进了封装,定义在头文件<atomic>中,这里不过多的介绍。Mac系统里有对原子操作的头文件stdatomic.h,本文的介绍也是基于这个头文件。
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 <iostream>
#include <stdatomic.h>
int main(int argc, const char * argv[]) {
atomic_uint _atomic_int;
atomic_init(&_atomic_int, 1);
uint32_t _a_int = 0;
std::cout<<atomic_is_lock_free(&_atomic_int)<<std::endl;
std::cout<<atomic_is_lock_free(&_a_int)<<std::endl;
return 0;
}
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 <stdatomic.h>
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实现不同的内存序
网友评论