【C++11并发】Atomic 笔记

简介

用atomic定义的变量,支持原子操作,即要么全部完成操作,要不全部没有完成,我们是不可能看到中间状态。一般在多线程程序中,可以用atomic来完成数据同步。
标准库为我们主要提供了四类工具

  1. atomic类模板
  2. 操作atomic的全局方法
  3. atomic_flag
  4. 内存顺序,即约束了当前atomic对象前后代码直行的相对顺序

atomic_flag是保证无锁的,任何平台都可以放心使用;atomic 对于整型,浮点类型,提供的方法会略有不同;内存顺序是在操作原子对象的时候,可以施加影响

atomic_flag

atomic_flag相当于是一个原子的bool类型,与atomic的不同点,除了无锁之外,atomic_flag提供的方法也是比较有限的,没有load和store方法:
【C++11并发】Atomic 笔记_第1张图片

构造了方法,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 
 
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对于不同的类型支持的方法不一样,任何类型都有的方法如下:
【C++11并发】Atomic 笔记_第2张图片
构造方法

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的别名,类似这样
【C++11并发】Atomic 笔记_第3张图片
对于整型atomic提供的额外方法有:
【C++11并发】Atomic 笔记_第4张图片
加法会返回之前的值

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

【C++11并发】Atomic 笔记_第5张图片

你可能感兴趣的:(C++11并发,c++,笔记)