C++ 多线程：std::atomic模板特化
cpp 多线程：std::atomic模板特化
文章目录
- cpp 多线程：std::atomic模板特化
-
- 概念
- 整数类型特化
- 指针类型特化
- 接口说明
-
- fetch_add
- fetch_sub
- ++, --,
- fetch_and，fetch_or，fetch_xor
- operator &=，operator |=，operator ^=，operator+=, operator-=
- std::atomic模板参数
概念
std::atomic<>的每个实例化和完全特化表示不同线程可以同时操作(它们的实例)的类型，而不会引发未定义的行为；另外，std::atomic<>通过允许各种 memory orders 为您提供更多控制权指定同步和排序约束。我前面两篇文章介绍了有关 cpp 11 原子和内存模型的更多信息，感兴趣的可以去阅读下。
对于整型和指针这些的原子类型，您可能会使用 overloaded arithmetic operators或 another set of them 做以下简单加减操作:
std::atomic<int> value(0);
value++; //This is an atomic op
value += 5; //And so is this
但是，上面这些操作忽略了我们前面介绍了内存模型 memory orders 带来的性能提升。因为操作符语法不允许你指定内存顺序，这些操作只能使用 std::memory_order_seq_cst 来执行，因为这是 cpp 11 中所有原子操作的默认顺序。它保证所有原子操作之间的顺序一致性(总全局排序)。在某些情况下，这可能无法满足要求，因此您可能需要使用更明确的形式:
std::atomic<long> value {0};
value.fetch_add(2, std::memory_order_relaxed); // Atomic, but there are no synchronization or ordering constraints
value.fetch_add(2, std::memory_order_release); // Atomic, performs 'release' operation
而且，我们都知道计算机更擅长处理整数以及指针，并且X86架构的CPU还提供了指令级的CAS操作。cpp11为了充分发挥计算的特长，针对非浮点数值(std::atmoic)及指针(std::atomic)进行了特化，以提高原子操作的性能。特化后的atomic在通用操作的基础上，还提供了更丰富的功能。它们拥有初等模板所不拥有的额外属性：额外支持适合指针/整型类型的原子算术运算，例如 fetch_add 、 fetch_sub等。
整数类型特化
以下整数类型之一实例化时， std::atomic 提供适合于整数类型的额外原子操作，例如 fetch_add 、 fetch_sub 、 fetch_and 、 fetch_or 、 fetch_xor ：
- 字符类型 char 、 char8_t (cpp20 起)、 char16_t 、 char32_t 和 wchar_t ；
- 标准有符号整数类型：signed char 、 short 、 int 、 long 和 long long ；
- 标准无符号整数类型：unsigned char 、 unsigned short 、 unsigned int 、 unsigned long 和 unsigned long long ；
- 任何头文件
类型定义
template <> struct atomic<integral> {
atomic() = default;
constexpr atomic(integral);
atomic(const atomic&) = delete;
bool is_lock_free() const volatile;
bool is_lock_free() const;
void store(integral, memory_order = memory_order_seq_cst) volatile;
void store(integral, memory_order = memory_order_seq_cst);
integral load(memory_order = memory_order_seq_cst) const volatile;
integral load(memory_order = memory_order_seq_cst) const;
operator integral() const volatile;
operator integral() const;
integral exchange(integral, memory_order = memory_order_seq_cst) volatile;
integral exchange(integral, memory_order = memory_order_seq_cst);
bool compare_exchange_weak(integral&, integral, memory_order, memory_order) volatile;
bool compare_exchange_weak(integral&, integral, memory_order, memory_order);
bool compare_exchange_strong(integral&, integral, memory_order, memory_order) volatile;
bool compare_exchange_strong(integral&, integral, memory_order, memory_order);
bool compare_exchange_weak(integral&, integral, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_weak(integral&, integral, memory_order = memory_order_seq_cst);
bool compare_exchange_strong(integral&, integral, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_strong(integral&, integral, memory_order = memory_order_seq_cst);
//原子对象的封装值加 val，并返回原子对象的旧值。整个过程是原子的
integral fetch_add(integral, memory_order = memory_order_seq_cst) volatile;
integral fetch_add(integral, memory_order = memory_order_seq_cst);
//原子对象的封装值减 val，并返回原子对象的旧值。整个过程是原子的
integral fetch_sub(integral, memory_order = memory_order_seq_cst) volatile;
integral fetch_sub(integral, memory_order = memory_order_seq_cst);
//原子地进行参数和原子对象的值的逐位与，并获得先前保有的值
integral fetch_and(integral, memory_order = memory_order_seq_cst) volatile;
integral fetch_and(integral, memory_order = memory_order_seq_cst);
// 原子地进行参数和原子对象的值的逐位或，并获得先前保有的值
integral fetch_or(integral, memory_order = memory_order_seq_cst) volatile;
integral fetch_or(integral, memory_order = memory_order_seq_cst);
// 原子地进行参数和原子对象的值的逐位异或，并获得先前保有的值
integral fetch_xor(integral, memory_order = memory_order_seq_cst) volatile;
integral fetch_xor(integral, memory_order = memory_order_seq_cst);
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
integral operator=(integral) volatile;
integral operator=(integral);
// 令原子值增加或减少一
integral operator++(int) volatile; //后缀++
integral operator++(int);
integral operator--(int) volatile; /后缀--
integral operator--(int);
integral operator++() volatile; //前缀++
integral operator++();
integral operator--() volatile; //前缀--
integral operator--();
// 加、减，或与原子值进行逐位与、或、异或
integral operator+=(integral) volatile;
integral operator+=(integral);
integral operator-=(integral) volatile;
integral operator-=(integral);
integral operator&=(integral) volatile;
integral operator&=(integral);
integral operator|=(integral) volatile;
integral operator|=(integral);
integral operator^=(integral) volatile;
integral operator^=(integral);
};
指针类型特化
类型定义
template <class T> struct atomic<T*> {
atomic() = default;
constexpr atomic(T*);
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
bool is_lock_free() const volatile;
bool is_lock_free() const;
void store(T*, memory_order = memory_order_seq_cst) volatile;
void store(T*, memory_order = memory_order_seq_cst);
T* load(memory_order = memory_order_seq_cst) const volatile;
T* load(memory_order = memory_order_seq_cst) const;
operator T*() const volatile;
operator T*() const;
T* exchange(T*, memory_order = memory_order_seq_cst) volatile;
T* exchange(T*, memory_order = memory_order_seq_cst);
bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile;
bool compare_exchange_weak(T*&, T*, memory_order, memory_order);
bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile;
bool compare_exchange_strong(T*&, T*, memory_order, memory_order);
bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);
bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);
// 上面的接口我们上一篇文章已经介绍过，这里不再介绍了
T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
T* operator=(T*) volatile;
T* operator=(T*);
T* operator++(int) volatile;
T* operator++(int);
T* operator--(int) volatile;
T* operator--(int);
T* operator++() volatile;
T* operator++();
T* operator--() volatile;
T* operator--();
T* operator+=(ptrdiff_t) volatile;
T* operator+=(ptrdiff_t);
T* operator-=(ptrdiff_t) volatile;
T* operator-=(ptrdiff_t);
};
接口说明
fetch_add
仅为 atomic 模板特化的成员
T fetch_add (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (T val, memory_order sync = memory_order_seq_cst) noexcept;
仅为 atomic 模板特化的成员
T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;
原子地以值和 val 的算术加法结果替换当前值。运算是读修改写操作。按照 order 的值影响内存。
对于有符号 Integral 类型，定义算术为使用补码。对于 T* 类型，结果可能为未定义的地址，但此外运算无未定义行为。
#include fetch_sub
// T is integral
T fetch_sub(T v, memory_order m = memory_order_seq_cst) volatile noexcept;
T fetch_sub(T v, memory_order m = memory_order_seq_cst) noexcept;
// T is pointer
T fetch_sub(ptrdiff_t v, memory_order m = memory_order_seq_cst) volatile noexcept;
T fetch_sub(ptrdiff_t v, memory_order m = memory_order_seq_cst) noexcept;
将原子对象的封装值减 val，并返回原子对象的旧值，适用于整形和指针类型的 std::atomic 特化版本，整个过程是原子的。其功能用伪代码表示为：
auto old = contained
contained -= v
return old
++, --,
自增运算符重载，有两种形式，第一种形式 (1) 返回自增后的值（即前缀++），第二种形式(2) 返回自增前的值（即后缀++），适用于整形和指针类型的 std::atomic 特化版本。
自减运算符重载，有两种形式， 第一种形式 (1) 返回自减后的值（即前缀–），第二种形式(2) 返回自减前的值（即后缀–），适用于整形和指针类型的 std::atomic 特化版本。
不管是基于整数的特化，还是指针特化，atomic均支持这两种种操作。其用法与未封装时一样，此处就不一一列举其函数原型了。
fetch_and，fetch_or，fetch_xor
位操作，将contained按指定方式进行位操作，并返回contained的旧值，仅用于整数的特化。
// T is only for integral
integral fetch_and(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_and(integral v, memory_order m = memory_order_seq_cst) noexcept;
integral fetch_or(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_or(integral v, memory_order m = memory_order_seq_cst) noexcept;
integral fetch_xor(integral v, memory_order m = memory_order_seq_cst) volatile noexcept;
integral fetch_xor(integral v, memory_order m = memory_order_seq_cst) noexcept;
以xor为例，其操作相当于：
auto old = contained
contained ^= v
return old
operator &=，operator |=，operator ^=，operator+=, operator-=
与相应的fetch_*操作不同的是，operator操作返回的是新值，仅用于整数的特化。
// T is only for integral
T operator &=(T v) volatile noexcept {return fetch_and(v) & v;}
T operator &=(T v) noexcept {return fetch_and(v) & v;}
T operator |=(T v) volatile noexcept {return fetch_or(v) | v;}
T operator |=(T v) noexcept {return fetch_or(v) | v;}
T operator ^=(T v) volatile noexcept {return fetch_xor(v) ^ v;}
T operator ^=(T v) noexcept {return fetch_xor(v) ^ v;}
// T is for pointer
T* operator+=(ptrdiff_t) volatile;
T* operator+=(ptrdiff_t);
T* operator-=(ptrdiff_t) volatile;
T* operator-=(ptrdiff_t);
// T is for integral
integral operator+=(integral) volatile;
integral operator+=(integral);
integral operator-=(integral) volatile;
integral operator-=(integral);
以上各个 operator 都会有对应的 fetch_* 操作，详细见下表：简单总结一下：
| 操作符 | 操作符重载函数 | 等级的成员函数 | 整形 | 指针 | 其他 |
|---|---|---|---|---|---|
| + | atomic::operator+= | atomic::fetch_add | 是 | 是 | 否 |
| - | atomic::operator-= | atomic::fetch_sub | 是 | 是 | 否 |
| & | atomic::operator&= | atomic::fetch_and | 是 | 是 | 否 |
| | | atomic::operator| = | atomic::fetch_or | 是 | 否 | 否 |
| atomic::operator^= | atomic::fetch_xor | 是 | 否 | 否 |
std::atomic模板参数
std::atomic 模板可用任何满足可复制构造 (CopyConstructible) 及可复制赋值 (CopyAssignable) 的可平凡复制 (TriviallyCopyable) 类型 T 特化。若下列任何值为 false 则T不可用于atomic模板：
- std::is_trivially_copyable::value
- std::is_copy_constructible::value
- std::is_move_constructible::value
- std::is_copy_assignable::value
- std::is_move_assignable::value
那么到底什么是TriviallyCopyable类型呢？有以下三种：
-
Scalar types(标量类型)
标量类型（Scalar type）是相对复合类型（Compound type）来说的：标量类型只能有一个值，而复合类型可以包含多个值。复合类型是由标量类型构成的。
在C语言中，整数类型（int、short、long等）、字符类型（char、wchar_t等）、枚举类型（enum）、小数类型（float、double等）、布尔类型（bool）都属于标量类型，一份标量类型的数据只能包含一个值。
结构体（struct）、数组(array)、字符串(string)都属于复合类型，一份复合类型的数据可以包含多个标量类型的值，也可以包含其他复合类型的值。
-
rivially copyable classes(拷贝不变类)，一个类型如果是trivially copyable，则使用memcpy这种方式把它的数据从一个地方拷贝出来会得到相同的结果。编译器如何判断一个类型是否trivially copyable呢？cpp标准把trivial类型定义如下，一个拷贝不变(trivially copyable)类型是指：：
- At least one copy constructor, move constructor, copy assignment operator, or move assignment operator is eligible，必须有一个拷贝构造函数，或者移动构造函数，或者拷贝赋值运算符，或者移动赋值运算符；
- Every eligible copy constructor (if any) is trivial，每个复制构造函数均为不变的；
- Every eligible move constructor (if any) is trivial，每个移动构造函数均为不变的；
- Every eligible copy assignment operator (if any) is trivial，每个复制赋值运算符均为不变的；
- Every eligible move assignment operator (if any) is trivial，每个移动赋值运算符均为不变的；
- Has a trivial non-deleted destructor，平凡而未弃置的析构函数；
-
Arrays of TriviallyCopyable objects可平凡复制 (TriviallyCopyable) 对象的数组。
一个trivial class类型是指有一个trivial类型的默认构造函数，而且是拷贝不变的(trivially copyable)的class。特别注意，拷贝不变类型和trivial类型都不能有虚机制。那么trivial和non-trivial类型到底是什么呢？这里给出一个非官方、不严谨的判断方式，方便大家对trivially copyable有一个直观的认识。一个trivial copyable类在四个点上没有自定义动作，也没有编译器加入的额外动作(如虚指针初始化就属额外动作)，这四个点是:
- 缺省构造。类必须支持缺省构造，同时类的非静态成员也不能有自定义或编译器加入的额外动作，否则编译器势必会隐式插入额外动作来初始化非静态成员。
- 拷贝构造、拷贝赋值
- move构造、move赋值
- 析构
为了加深理解，我们来看一下下面的例子(所有的类都是trivial的)：
// 空类
struct A1 {};
// 成员变量是trivial的
struct A2 {
int x;
};
// 基类是trivial的
struct A3 : A2 {
// 非用户自定义的构造函数(使用编译器提供的default构造)
A3() = default;
int y;
};
struct A4 {
int a;
private: // 对防问限定符没有要求，A4仍然是trivial的
int b;
};
struct A5 {
A1 a;
A2 b;
A3 c;
A4 d;
};
struct A6 {
// A2是trivial，它的array也是trivial
A2 a[16];
};
struct A7 {
A6 c;
void f(); // 普通成员函数是允许的
};
struct A8 {
int x;
// 对静态成员无要求(std::string是non-trivial的)
static std::string y;
};
struct A9 {
// 非用户自定义
A9() = default;
// 普通构造函数是可以的(前提是我们已经有了非定义的缺省构造函数)
A9(int x) : x(x) {};
int x;
};
而下面这些类型都是non-trivial的：
struct B {
// 有虚函数(编译器会隐式生成缺省构造，同时会初始化虚函数指针)
virtual f();
};
struct B2 {
// 用户自定义缺省构造函数
B2() : z(42) {}
int z;
};
struct B3 {
// 用户自定义缺省构造函数
B3();
int w;
};
// 虽然使用了default，但在缺省构造声明处未指定，因此被判断为non-trivial的
NonTrivial3::NonTrivial3() = default;
struct B4 {
// 虚析构是non-trivial的
virtual ~B4();
};
STL在其头文件
template <typename T>
struct std::is_trivially_copyable;
判断类A是否trivially copyable:std::is_trivially_copyable::value，该值是一个const bool类型，如果为true则是trivially copyable的，否则不是。
参考
std::atomic - cpp中文 - API参考文档 (apiref.com)