C++ `std::atomic_ref`：C++20 对非原子对象的原子视图

好的，各位观众老爷，今天咱们来聊聊C++20里一个挺有意思的小玩意儿：std::atomic_ref。这玩意儿啊，说白了，就是给那些本来不是原子类型的变量，强行套上一层“原子”的外壳，让它们也能参与到原子操作的行列中来。

一、啥是原子操作？为啥需要它？

在深入std::atomic_ref之前，咱们先得搞清楚啥是原子操作。想象一下，你和你的小伙伴同时往一个银行账户里存钱。

非原子操作： 假设你们的操作是这样的：
1. 读取账户余额。
2. 加上要存的钱。
3. 把新的余额写回账户。
如果你们俩同时执行，可能就会出现问题。比如：
- 你读到余额是100块。
- 你小伙伴也读到余额是100块。
- 你加上你的50块，算出新的余额是150块。
- 你小伙伴加上他的100块，算出新的余额是200块。
- 你把150块写回账户。
- 你小伙伴把200块写回账户，覆盖了你的结果。
最后，账户余额变成了200块，你少了50块，小伙伴多了50块，银行亏了，大家都哭了。
原子操作： 原子操作就像一个“事务”，要么全部完成，要么全部不完成。在这个例子里，原子操作会保证在读取余额、加上存款、写回余额这三个步骤中，不会有其他人来干扰。这样就能保证账户余额的正确性。

所以，原子操作主要解决的就是多线程并发访问共享资源时的数据竞争问题。C++11引入了std::atomic系列类型，专门用来进行原子操作。但是，问题来了，如果我有一个现成的变量，它不是std::atomic类型的，我能不能也让它参与到原子操作中呢？

二、std::atomic_ref：原子操作的“马甲”

std::atomic_ref就是为了解决这个问题而生的。它本质上是一个对现有变量的引用，但这个引用允许你对被引用的变量执行原子操作。你可以把它想象成给一个非原子变量穿上了一件“原子马甲”。

语法：

#include <atomic>

std::atomic_ref<T> ref(T& obj); // 构造一个原子引用，引用一个类型为 T 的对象 obj

简单例子：

#include <iostream>
#include <atomic>
#include <thread>

int main() {
  int non_atomic_int = 0;
  std::atomic_ref<int> atomic_ref_int(non_atomic_int);

  std::thread t1([&]() {
    for (int i = 0; i < 100000; ++i) {
      atomic_ref_int++; // 原子递增
    }
  });

  std::thread t2([&]() {
    for (int i = 0; i < 100000; ++i) {
      atomic_ref_int++; // 原子递增
    }
  });

  t1.join();
  t2.join();

  std::cout << "non_atomic_int: " << non_atomic_int << std::endl; // 打印结果为200000
  return 0;
}

在这个例子中，non_atomic_int本来是一个普通的int变量，但是通过std::atomic_ref<int> atomic_ref_int(non_atomic_int)，我们创建了一个对它的原子引用。然后，我们就可以用atomic_ref_int++来原子地递增non_atomic_int的值了。即使在多线程环境下，也能保证结果的正确性。

三、std::atomic_ref的优势和限制

优势：

灵活性： 可以对已有的非原子变量进行原子操作，无需修改变量的类型。
避免复制： std::atomic在构造时会复制一份变量，而std::atomic_ref只是引用，避免了额外的内存开销和复制操作。
更好的兼容性： 有些老代码可能无法直接使用std::atomic类型，std::atomic_ref提供了一种更平滑的迁移方案。

限制：

生命周期： std::atomic_ref的生命周期必须小于等于被引用对象的生命周期。如果被引用对象已经销毁，std::atomic_ref会变成悬空引用，导致未定义行为。
不能重新绑定： std::atomic_ref在构造时就绑定了引用的对象，之后不能重新绑定到其他对象。
并非真正的原子类型： std::atomic_ref只是提供了一种原子访问的视图，它并没有改变被引用对象的本质。如果其他线程直接访问被引用对象，仍然可能出现数据竞争。
并非所有类型都支持： 只有满足特定要求的类型才能用std::atomic_ref进行原子操作。这些要求主要包括：平凡可复制 (TriviallyCopyable)、平凡可移动 (TriviallyMoveable) 和具有统一大小 (Same Size)。

四、std::atomic_ref能干啥？应用场景举例

现有代码的原子化改造： 比如，你有一个很大的代码库，里面有很多非原子变量，现在需要进行多线程优化。如果直接把所有变量都改成std::atomic类型，改动量会很大，而且可能会破坏现有的代码结构。这时，你可以使用std::atomic_ref，只对需要原子操作的变量创建原子引用，从而减少改动量。
共享内存的原子访问： 在共享内存的场景下，多个进程可能需要访问同一个变量。std::atomic_ref可以让你在不改变变量类型的情况下，进行原子操作，保证数据的一致性。
性能优化： 在某些情况下，使用std::atomic_ref可以避免不必要的复制操作，从而提高性能。

五、std::atomic_ref的用法详解：更多代码示例

1. 基本的原子操作：

#include <iostream>
#include <atomic>

int main() {
  int data = 0;
  std::atomic_ref<int> atomic_data(data);

  atomic_data.store(10); // 原子存储
  std::cout << "Data: " << data << std::endl; // 输出：Data: 10

  int value = atomic_data.load(); // 原子加载
  std::cout << "Value: " << value << std::endl; // 输出：Value: 10

  int old_value = atomic_data.exchange(20); // 原子交换
  std::cout << "Old Value: " << old_value << std::endl; // 输出：Old Value: 10
  std::cout << "Data: " << data << std::endl; // 输出：Data: 20

  return 0;
}

2. 原子比较和交换 (compare_exchange_weak/strong)：

#include <iostream>
#include <atomic>

int main() {
  int data = 10;
  std::atomic_ref<int> atomic_data(data);

  int expected = 10;
  int desired = 20;

  bool exchanged = atomic_data.compare_exchange_strong(expected, desired); // 原子比较和交换
  std::cout << "Exchanged: " << exchanged << std::endl; // 输出：Exchanged: 1
  std::cout << "Data: " << data << std::endl; // 输出：Data: 20

  expected = 30;
  desired = 40;
  exchanged = atomic_data.compare_exchange_strong(expected, desired);
  std::cout << "Exchanged: " << exchanged << std::endl; // 输出：Exchanged: 0
  std::cout << "Data: " << data << std::endl; // 输出：Data: 20
  std::cout << "Expected: " << expected << std::endl; // 输出：Expected: 20

  return 0;
}

compare_exchange_strong和compare_exchange_weak都是用来进行原子比较和交换的，它们的区别在于：

compare_exchange_strong： 保证只有在当前值等于expected时，才能成功交换为desired。如果交换失败，说明在比较的过程中，有其他线程修改了值，导致当前值和expected不相等。
compare_exchange_weak： 允许在当前值等于expected时，也可能交换失败（即使没有其他线程修改值）。这听起来有点奇怪，但这是因为compare_exchange_weak在某些平台上可以用更高效的指令实现。

通常情况下，我们应该优先使用compare_exchange_strong，因为它更可靠。只有在对性能有极致要求，并且能够容忍伪失败的情况下，才考虑使用compare_exchange_weak。在使用compare_exchange_weak时，通常需要在一个循环中进行重试，直到交换成功为止。

#include <iostream>
#include <atomic>

int main() {
    int data = 10;
    std::atomic_ref<int> atomic_data(data);

    int expected = 10;
    int desired = 20;

    while (!atomic_data.compare_exchange_weak(expected, desired)) {
        // 如果交换失败，expected会被更新为当前值，然后重试
        std::cout << "Compare exchange weak failed, retrying. Expected: " << expected << std::endl;
    }

    std::cout << "Data: " << data << std::endl; // Data: 20

    return 0;
}

3. 原子加减操作：

#include <iostream>
#include <atomic>

int main() {
  int data = 0;
  std::atomic_ref<int> atomic_data(data);

  atomic_data += 10; // 原子加
  std::cout << "Data: " << data << std::endl; // 输出：Data: 10

  atomic_data -= 5; // 原子减
  std::cout << "Data: " << data << std::endl; // 输出：Data: 5

  int old_value = atomic_data.fetch_add(5); // 原子加并返回旧值
  std::cout << "Old Value: " << old_value << std::endl; // 输出：Old Value: 5
  std::cout << "Data: " << data << std::endl; // 输出：Data: 10

  old_value = atomic_data.fetch_sub(2); // 原子减并返回旧值
  std::cout << "Old Value: " << old_value << std::endl; // 输出：Old Value: 10
  std::cout << "Data: " << data << std::endl; // 输出：Data: 8

  return 0;
}

六、关于内存顺序 (Memory Order)

原子操作还有一个重要的概念就是内存顺序。内存顺序决定了原子操作与其他操作之间的happens-before关系，也就是操作的可见性。C++提供了多种内存顺序选项，包括：

std::memory_order_relaxed：最宽松的内存顺序，只保证原子性，不保证顺序性。
std::memory_order_acquire：用于读取操作，保证在读取操作之后，所有后续的读取和写入操作都能看到该读取操作的结果。
std::memory_order_release：用于写入操作，保证在写入操作之前，所有之前的读取和写入操作都已经完成。
std::memory_order_acq_rel：同时具有acquire和release的语义，通常用于读-修改-写操作。
std::memory_order_seq_cst：最严格的内存顺序，保证所有原子操作都按照一个全局唯一的顺序执行。

选择合适的内存顺序非常重要，错误的内存顺序可能会导致数据竞争或者性能下降。通常情况下，我们应该优先使用std::memory_order_seq_cst，因为它最安全。只有在对性能有极致要求，并且对并发模型有深入理解的情况下，才考虑使用其他内存顺序。

例子：

#include <iostream>
#include <atomic>
#include <thread>

std::atomic_bool ready = false;
int data = 0;

void producer() {
    data = 42;
    ready.store(true, std::memory_order_release); // 使用 release 语义
}

void consumer() {
    while (!ready.load(std::memory_order_acquire)) { // 使用 acquire 语义
        // 等待 producer 线程设置 ready 为 true
    }
    std::cout << "Data: " << data << std::endl; // 保证能看到 producer 线程写入的 data 值
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();

    return 0;
}

在这个例子中，producer线程使用std::memory_order_release来写入ready变量，consumer线程使用std::memory_order_acquire来读取ready变量。这样就能保证在consumer线程看到ready为true之后，也能看到producer线程写入的data值。

七、std::atomic_ref与std::atomic的对比

为了更好地理解std::atomic_ref，咱们把它和std::atomic做个对比：

特性	`std::atomic`	`std::atomic_ref`
本质	一个原子类型，存储一个原子值。	一个对现有变量的原子引用。
存储	拥有自己的存储空间，会复制一份变量。	不拥有自己的存储空间，只是引用现有变量。
初始化	可以在构造时初始化，也可以之后赋值。	必须在构造时绑定一个现有的变量，之后不能重新绑定。
生命周期	生命周期独立于被复制的变量。	生命周期必须小于等于被引用变量的生命周期。
适用场景	需要原子类型的变量，或者需要独立存储原子值的情况。	需要对现有非原子变量进行原子操作，或者避免复制的情况。
修改现有代码	需要修改变量的类型。	无需修改变量的类型，只需要创建原子引用。
内存开销	会增加额外的内存开销，因为需要存储一份变量。	没有额外的内存开销，只是引用现有变量。

八、使用std::atomic_ref的注意事项

生命周期管理： 务必保证std::atomic_ref的生命周期小于等于被引用对象的生命周期，否则会导致未定义行为。
数据竞争： 虽然std::atomic_ref提供了原子访问的视图，但如果其他线程直接访问被引用对象，仍然可能出现数据竞争。因此，在使用std::atomic_ref时，要确保所有线程都通过原子引用来访问共享变量。
类型要求： 只有满足特定要求的类型才能用std::atomic_ref进行原子操作。
避免过度使用： 不要为了原子化而原子化，只有在真正需要原子操作的场景下才使用std::atomic_ref。

九、总结

std::atomic_ref是C++20引入的一个非常有用的工具，它可以让我们在不改变变量类型的情况下，对现有的非原子变量进行原子操作。它具有灵活性、避免复制、更好的兼容性等优点，但也存在生命周期限制、不能重新绑定、并非真正的原子类型等限制。在使用std::atomic_ref时，要注意生命周期管理、数据竞争、类型要求等问题，并选择合适的内存顺序。

总的来说，std::atomic_ref就像一个原子操作的“马甲”，可以让我们更方便地进行多线程编程，提高程序的并发性能。但是，在使用它的时候，一定要小心谨慎，避免踩坑。好了，今天的分享就到这里，希望对大家有所帮助！

发表回复 取消回复

发表回复取消回复