美文网首页iOS面试八股文
C语言的原子操作

C语言的原子操作

作者: 薛定喵的鹅 | 来源:发表于2021-05-08 16:20 被阅读0次

    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_storeatomic_store_explicit:是原子写入操作,将原子对象的值更换为desired的值。
    obj:原子对象的指针。
    desired:期望写入的值。
    order:内存模型。atomic_store带有缺省的内存模型是:memory_order_seq_cstatomic_store_explicit可使用的内存模型有:memory_order_relaxedmemory_order_releasememory_order_seq_cst

    读取(Load operation )

    C atomic_load( const volatile A* obj );
    C atomic_load_explicit( const volatile A* obj, memory_order order);
    

    atomic_loadatomic_load_explicit:是原子读取操作,返回原子对象的值。
    obj:原子对象的指针。
    order:内存模型。atomic_load带有缺省的内存模型是:memory_order_seq_cst;可使用的内存模型有:memory_order_relaxedmemory_order_acquirememory_order_consumememory_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_exchangeatomic_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_relaxedmemory_order_acquirememory_order_consumememory_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_setatomic_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_clearatomic_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 orderingmemory_order_releasememory_order_acquire往往是配对使用。如果线程A针对一个原子对象进行memory_order_releasestore操作,线程B针对这个原子对象进行memory_order_acquireload操作,那么线程A中发生在store之前的所有的内存写入(relaxed原子的或者非原子的),都是对线程B执行load后可见的。

    这种同步是建立在不同线程针对同一个原子对象做 releasing storeacquiring load操作之上的。

    memory_order_consume:修饰读取操作(load),表示在本线程中,在这个语句后并且依赖这个原子变量的读写操作不能重排到load这个语句的前面。所有其他线程被使用来完成store操作的变量内存的写入,对本线程是可见的。
    memory_order_consumememory_order_acquire约束更小,只影响和这个原子对象相关的内存读写重排。

    memory_order_acq_rel:修饰读取-修改-写入操作,表示该操作既是一个acquire操作也是一个release操作。在当前线程中,写入操作的前后内存读写都不可以重排。其他所有线程针对该原子对象的release操作的内存写入,在本线程改变修改操作之前是可见的;对于内存的修改,其他线程在acquire该原子对象前是可见的。

    memory_order_seq_cst:这个是memory_order_releasememory_order_acquirememory_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实现不同的内存序

    相关文章

      网友评论

        本文标题:C语言的原子操作

        本文链接:https://www.haomeiwen.com/subject/vmuelltx.html