C++中的atomic：原子

在多线程编程中，原子操作是一种重要的技术，可以确保在并发环境中进行无锁操作。C++11 引入了 std::atomic<>，提供了一种无锁的机制来操作变量，确保在并发环境中访问和修改变量时没有数据竞争。本文将介绍 std::atomic<> 的基本概念、使用场景以及实现原理，并提供一些示例代码来说明其用法。

什么是原子操作？

原子操作是指在多线程环境下，不可分割的操作，即在进行操作时不会被其他线程打断。原子操作是一种以单个事务来执行的操作，其他线程只能看到操作完成前或者完成后的资源状态，不存在中间状态可视。从底层来看，原子操作是一些硬件指令，其原子性由硬件保证，C++11 对原子操作进行了抽象，提供了统一的接口，避免使用时嵌入平台相关的代码来支持跨平台使用。

为什么需要 `std::atomic<>`？

虽然 C++11 提供了其他高并发的 API，例如互斥锁（std::mutex）和条件变量（std::condition_variable），但这些 API 在某些情况下并不是最佳选择：

性能开销：互斥锁的实现通常依赖于操作系统的系统调用，这可能带来较大的性能开销。相反，std::atomic<> 的操作通常是无锁的，直接使用底层硬件提供的原子操作，性能更高。
避免死锁：使用互斥锁需要小心处理锁的获取和释放，否则容易导致死锁。std::atomic<> 不需要显式加锁和解锁，减少了编程复杂性。
细粒度控制：std::atomic<> 提供了对单个变量的细粒度控制，使得某些简单的并发场景可以更高效地实现。

使用 `std::atomic<>`

std::atomic<> 是一个模板类，可以实例化各种类型的原子操作。然而，并不是所有类型都可以实例化 std::atomic<> 模板。按照标准的说法，需要是 Trivially Copyable 的类型，简单来说就是满足以下三个条件：

连续的内存；
拷贝对象意味着按 bit 拷贝（memcpy）；
没有虚函数。

用代码来表达则是自定义结构满足下面五个条件：

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

示例代码

下面的代码演示了如何使用 std::atomic<> 进行各种原子操作：

#include <ostream>
#include "XLogger.h"
#include <atomic>
#include <sstream>
#include <type_traits>class AtomicInfo {};class q_atomic {
public:q_atomic() {std::atomic<int32_t> int32_atomic(100);int32_atomic++;int32_atomic--;++int32_atomic;std::atomic<bool> bool_atomic(false);/*** 读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，* 整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。*/std::atomic<bool> atomicBool2 = bool_atomic.exchange(true, std::memory_order_relaxed);bool_atomic = true;std::atomic<AtomicInfo> info_atomic;// 这个错误信息指出 _Atomic 不能应用于 std::string 类型，因为 std::string 不是可平凡复制（trivially copyable）的类型。// C++ 中 std::atomic<> 只能用于可平凡复制的类型，例如基本数据类型（如 int、float）和某些自定义类型，但 std::string 不符合这一要求。// todo 为什么 std::string 不能直接用于 std::atomic<>？//  std::string 是一个复杂的类型，包含动态分配的内存，其复制操作涉及更多的资源管理，不能保证在并发环境下安全地进行无锁操作。//  使用锁 或 包装string std::atomic<std::shared_ptr<std::string>> atomicString(std::make_shared<std::string>("")); 规避//std::atomic<std::string> str_atomic;}void bring() {std::atomic<int32_t> atomicInt(100);/*** 修改被封装的值* void store(_Tp __d, memory_order __m = memory_order_seq_cst)* memory_order __m,指定内存序，操作的类别决定了内存次序所准许的取值。若我们没有把内存次序显式设定成上面的值，*    则默认采用最严格的内存次序，即std::memory_order_seq_cst*/atomicInt.store(100, std::memory_order_seq_cst);/*** 读取被封装的值* _Tp load(memory_order __m = memory_order_seq_cst)*/int32_t result = atomicInt.load();/*** 检查std::atomic对象是否为无锁实现。* 返回值：bool，如果当前平台支持无锁实现，返回true，否则返回false。** 判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞* 这是一个运行时的判断（C++17提供了编译时判断constexpr is_always_lock_free()），之所以会出现无锁不确定的情况主要是因为对齐alignment。*/bool is_lock_free = atomicInt.is_lock_free();XLOG_INFO("is_lock_free: {0}", is_lock_free);//true/*** 设置原子对象的新值，并返回旧值。* 将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。*/atomicInt.exchange(12, std::memory_order_seq_cst);/*** 原子地比较并交换值。与compare_exchange_weak不同，它在失败时不会进行多次尝试。* 比较并交换被封装的值与参数 expected 所指定的值是否相等，如果：*    相等，则用 val 替换原子对象的旧值*    不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。** 如果值被交换，返回true，否则返回false** Tp& __e,预期值的引用* _Tp __d,要设置的新值。* memory_order __s, 成功的内存序* memory_order __f, 失败的内存序* bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f)*/int32_t expected = 10;bool success_ = atomicInt.compare_exchange_strong(expected, 199,std::memory_order_seq_cst, std::memory_order_seq_cst);XLOG_INFO("compare_exchange_strong: {0}", success_);/*** 比较并交换（弱版本，可能会伪失败）。* 与compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允许原子对象所封装的值与参数 expected 的物理内容相同，但却仍然返回 false，* 不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判断确实发生了伪失败(spurious failures)——即使原子对象所封装的值与参数 expected 的物理内容相同，* 但判断操作的结果却为 false，compare_exchange_weak函数返回 false，并且参数 expected 的值不会改变。** 对于某些不需要采用循环操作的算法而言, 通常采用compare_exchange_strong 更好** 如果 atomicInt == expected，则 atomicInt = 20并返回true，否则返回false并将expected设为atomic_int的值*/bool exchanged = atomicInt.compare_exchange_weak(expected, 20);XLOG_INFO("compare_exchange_weak: {0}", exchanged);/*** 原子加法，返回旧值。可选的内存顺序，默认为memory_order_seq_cst。*/int add_ret = atomicInt.fetch_add(123);/*** 原子减法，返回旧值。可选的内存顺序，默认为memory_order_seq_cst。*/int sub_ret = atomicInt.fetch_sub(100);//原子或操作，返回旧值。atomicInt.fetch_or(1);//原子与操作，返回旧值。//old_value = 0b1100, atomic_int = 0b1000int old_value = atomicInt.fetch_and(0b1010);//原子异或操作，返回旧值。atomicInt.fetch_xor(11);//等待直到atomic_int的值不等于10atomicInt.wait(10);atomicInt.notify_one();atomicInt.notify_all();//通知等待的所有线程。/*** 实际调用了 operator T() const, 将foo 强制转换成 int 类型,然后调用 operator=().* 与 load 功能类似，也是读取被封装的值，operator T() 是类型转换(type-cast)操作，* 默认的内存序是 std::memory_order_seq_cst，如果需要指定其他的内存序，应该使用 load() 函数。*/std::atomic<int32_t> atomicInt2 = static_cast<int>(atomicInt);}void task1() {//编译时常量布尔值，用于检查类型 T 是否是可平凡复制的。一个类型是可平凡复制的，// 意味着它的复制操作（拷贝构造、拷贝赋值）都可以通过简单的内存复制（如 memcpy）完成，而不需要自定义的拷贝逻辑。bool copyable = std::is_trivially_copyable<std::string>::value;XLOG_INFO("std::string-->is_trivially_copyable: {0}", copyable);//false//编译时常量布尔值，用于检查类型 T 是否是可拷贝构造的。即，类型 T 是否可以通过拷贝构造函数创建新的对象。//用途: 在模板代码中判断类型是否支持拷贝构造，确保只有支持拷贝构造的类型才能被某些模板实例化。bool constructible = std::is_copy_constructible<std::string>::value;XLOG_INFO("std::string-->is_copy_constructible: {0}", constructible);//truebool is_copy_assignable=std::is_copy_assignable<int32_t>::value;XLOG_INFO("int32_t-->is_copy_assignable: {0}", is_copy_assignable);//true//编译时常量布尔值，用于检查类型 T 是否是可移动赋值的。即，类型 T 是否可以通过移动赋值运算符进行赋值操作。//用途: 在模板代码中判断类型是否支持移动赋值，从而优化代码性能，减少不必要的拷贝操作。bool move_assignable = std::is_move_assignable<int32_t>::value;XLOG_INFO("int32_t-->is_move_assignable: {0}", move_assignable);//truecheckTypeTraits<int32_t>();checkTypeTraits<long>();checkTypeTraits<std::string>();}template <typename T>void checkTypeTraits() {std::cout << "Is trivially copyable: " << std::is_trivially_copyable<T>::value << std::endl;std::cout << "Is copy constructible: " << std::is_copy_constructible<T>::value << std::endl;std::cout << "Is move constructible: " << std::is_move_constructible<T>::value << std::endl;std::cout << "Is copy assignable: " << std::is_copy_assignable<T>::value << std::endl;std::cout << "Is move assignable: " << std::is_move_assignable<T>::value << std::endl;}~q_atomic() {}private:
};

注意事项

std::atomic<> 只能用于可平凡复制的类型，例如基本数据类型（如 int、float）和某些自定义类型，但 std::string 不符合这一要求。std::string 是一个复杂的类型，包含动态分配的内存，其复制操作涉及更多的资源管理，不能保证在并发环境下安全地进行无锁操作。
可以使用 std::atomic<std::shared_ptr<std::string>> 来处理 std::string，这是一种间接方式，确保线程安全。