std::atomic_ref ​

什么是 std::atomic_ref ​

std::atomic_ref<T> 是 C++20 引入的类模板,定义在 <atomic> 头文件中。它为一个普通的(非原子的)对象提供原子操作的能力,而不需要改变对象本身的类型。

std::atomic<T> 需要把对象声明为原子类型,所有访问都是原子的。而 std::atomic_ref<T> 可以对一个普通变量临时施加原子操作——只在需要并发访问时使用原子操作,其余时间用普通方式访问,避免不必要的同步开销。

cpp
#include <atomic>

int counter = 0;  // 普通变量

// 需要原子操作时,创建 atomic_ref
std::atomic_ref<int> ref(counter);
ref++;  // 原子递增

atomic_ref vs atomic ​

特性std::atomic_refstd::atomic
对象类型引用普通对象对象本身是原子的
创建时机按需创建声明时确定
性能只在需要时有同步开销所有访问都有开销
拷贝原对象不拷贝(引用)拷贝初始值
生命周期不能超过被引用对象独立
适用场景部分代码需要原子访问全程需要原子访问

基本示例 ​

cpp
#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
#include <mutex>
#include <string>
#include <numeric>
#include <array>

std::mutex cout_mutex;

void safe_print(const std::string& msg) {
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << msg << std::endl;
}

// ============================
// 示例1:基本用法——对普通变量做原子操作
// ============================

void basic_demo() {
    int value = 0;

    std::vector<std::jthread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back([&value] {
            // 创建 atomic_ref 来原子地递增 value
            std::atomic_ref<int> ref(value);
            for (int j = 0; j < 1000; j++) {
                ref++;  // 原子递增
            }
        });
    }

    threads.clear();  // 等待所有线程完成
    std::cout << "结果: " << value << " (应为 10000)" << std::endl;
}

// ============================
// 示例2:为什么不用 std::atomic
// ============================

struct ExpensiveData {
    int counter = 0;
    double values[100] = {};  // 大量数据

    double sum() const {
        double s = 0;
        for (double v : values) s += v;
        return s + counter;
    }
};

void why_not_atomic_demo() {
    ExpensiveData data;

    // 填充数据(单线程,不需要原子操作)
    for (int i = 0; i < 100; i++) {
        data.values[i] = i * 0.5;
    }

    // 多线程并发修改 counter(需要原子操作)
    std::vector<std::jthread> threads;
    for (int i = 0; i < 5; i++) {
        threads.emplace_back([&data] {
            // 只对 counter 做原子操作,不影响其他成员
            std::atomic_ref<int> counter_ref(data.counter);
            for (int j = 0; j < 100; j++) {
                counter_ref.fetch_add(1);
            }
        });
    }

    threads.clear();
    std::cout << "counter: " << data.counter << " (应为 500)" << std::endl;
    std::cout << "sum: " << data.sum() << std::endl;
}

// ============================
// 示例3:数组元素的原子操作
// ============================

void array_demo() {
    std::array<int, 5> arr = {0, 0, 0, 0, 0};

    std::vector<std::jthread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back([&arr, i] {
            // 对数组中的特定元素做原子操作
            int index = i % 5;
            std::atomic_ref<int> elem(arr[index]);
            for (int j = 0; j < 100; j++) {
                elem++;
            }
        });
    }

    threads.clear();

    std::cout << "数组: ";
    for (int v : arr) {
        std::cout << v << " ";  // 每个元素应为 200
    }
    std::cout << std::endl;
}

// ============================
// 示例4:fetch_add 和 fetch_sub
// ============================

void fetch_demo() {
    int value = 100;
    std::atomic_ref<int> ref(value);

    // fetch_add 返回旧值
    int old = ref.fetch_add(10);
    std::cout << "fetch_add(10): 旧值=" << old << ", 新值=" << value << std::endl;

    // fetch_sub 返回旧值
    old = ref.fetch_sub(30);
    std::cout << "fetch_sub(30): 旧值=" << old << ", 新值=" << value << std::endl;

    // 运算符
    ref += 5;
    std::cout << "+= 5: " << value << std::endl;

    int current = ref.load();
    std::cout << "load: " << current << std::endl;

    ref.store(42);
    std::cout << "store(42): " << value << std::endl;
}

// ============================
// 示例5:compare_exchange(CAS 操作)
// ============================

void cas_demo() {
    int value = 10;
    std::atomic_ref<int> ref(value);

    // compare_exchange_strong:如果当前值等于 expected,则替换为 desired
    int expected = 10;
    bool success = ref.compare_exchange_strong(expected, 20);
    std::cout << std::boolalpha;
    std::cout << "CAS(10->20): " << success << ", value=" << value << std::endl;

    // 再次尝试,expected 不匹配
    expected = 10;  // 已经被改成 20 了
    success = ref.compare_exchange_strong(expected, 30);
    std::cout << "CAS(10->30): " << success
              << ", expected 被更新为=" << expected << std::endl;
}

// ============================
// 示例6:浮点数的原子操作
// ============================

void float_demo() {
    double total = 0.0;

    std::vector<std::jthread> threads;
    for (int i = 0; i < 8; i++) {
        threads.emplace_back([&total, i] {
            std::atomic_ref<double> ref(total);
            for (int j = 0; j < 100; j++) {
                ref.fetch_add(1.0);
            }
        });
    }

    threads.clear();
    std::cout << "浮点数累加: " << total << " (应为 800)" << std::endl;
}

// ============================
// 示例7:is_always_lock_free 检查
// ============================

void lock_free_demo() {
    std::cout << std::boolalpha;
    std::cout << "int lock-free: "
              << std::atomic_ref<int>::is_always_lock_free << std::endl;
    std::cout << "double lock-free: "
              << std::atomic_ref<double>::is_always_lock_free << std::endl;
    std::cout << "long long lock-free: "
              << std::atomic_ref<long long>::is_always_lock_free << std::endl;

    // 大结构体可能不是 lock-free
    struct Big { int data[100]; };
    std::cout << "Big struct lock-free: "
              << std::atomic_ref<Big>::is_always_lock_free << std::endl;
}

// ============================
// 示例8:按需原子——性能优化模式
// ============================

void on_demand_demo() {
    int shared_value = 0;

    // 阶段1:单线程初始化(不需要原子操作)
    shared_value = 42;
    std::cout << "初始化后: " << shared_value << std::endl;

    // 阶段2:多线程并发修改(需要原子操作)
    std::vector<std::jthread> threads;
    for (int i = 0; i < 4; i++) {
        threads.emplace_back([&shared_value] {
            std::atomic_ref<int> ref(shared_value);
            ref.fetch_add(1);
        });
    }
    threads.clear();
    std::cout << "并发修改后: " << shared_value << std::endl;

    // 阶段3:单线程读取(不需要原子操作)
    int result = shared_value * 2;
    std::cout << "最终结果: " << result << std::endl;
}

int main() {
    std::cout << "=== 基本用法 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 结构体成员 ===" << std::endl;
    why_not_atomic_demo();

    std::cout << "\n=== 数组元素 ===" << std::endl;
    array_demo();

    std::cout << "\n=== fetch 操作 ===" << std::endl;
    fetch_demo();

    std::cout << "\n=== CAS 操作 ===" << std::endl;
    cas_demo();

    std::cout << "\n=== 浮点数 ===" << std::endl;
    float_demo();

    std::cout << "\n=== lock-free 检查 ===" << std::endl;
    lock_free_demo();

    std::cout << "\n=== 按需原子 ===" << std::endl;
    on_demand_demo();

    return 0;
}

atomic_ref 支持的操作 ​

操作整数类型浮点类型指针类型自定义类型
load / store支持支持支持支持
exchange支持支持支持支持
compare_exchange支持支持支持支持
fetch_add / fetch_sub支持支持支持不支持
fetch_and / fetch_or / fetch_xor支持不支持不支持不支持
++ / --支持不支持支持不支持

适用场景 ​

  • 结构体中只有部分成员需要原子访问
  • 数组中特定元素的原子操作
  • 部分代码路径需要原子访问,其余不需要
  • 不想改变现有类型定义(不想把 int 改成 atomic<int>)
  • 与第三方库交互,无法修改其数据类型

常见问题 ​

atomic_ref 的对齐要求是什么?

被引用的对象必须满足 atomic_ref<T>::required_alignment 的对齐要求。对于基本类型,这通常等于 alignof(T)。如果对齐不满足,行为未定义。

多个 atomic_ref 引用同一个对象安全吗?

安全的。多个 atomic_ref 可以同时引用同一个对象,它们的原子操作会正确同步。

atomic_ref 存在时可以直接访问原对象吗?

不可以。如果存在活跃的 atomic_ref 引用某个对象,同时通过普通方式访问该对象是数据竞争(未定义行为)。

T 必须满足什么要求?

T 必须是可平凡复制的(TriviallyCopyable)类型。

注意事项 ​

  • 被引用对象的生命周期必须长于 atomic_ref
  • 被引用对象必须满足对齐要求
  • atomic_ref 存在期间不能通过非原子方式访问对象
  • T 必须是 TriviallyCopyable 的
  • atomic_ref 本身可以复制——多个副本引用同一对象
  • 大对象的 atomic_ref 可能不是 lock-free

总结 ​

std::atomic_ref<T> 让你在不改变对象类型的情况下对其执行原子操作。与 std::atomic<T> 不同,atomic_ref 是"按需原子"——只在需要并发访问的代码路径上创建 atomic_ref,其余时间用普通方式访问,避免不必要的同步开销。它特别适合结构体中只有部分成员需要原子访问、数组元素的并发修改、以及无法修改类型定义的场景。atomic_ref 支持 load、store、exchange、compare_exchange、fetch_add 等完整的原子操作集,接口与 std::atomic 保持一致。