std::atomic_ref
什么是 std::atomic_ref
std::atomic_ref<T> 是 C++20 引入的类模板,定义在 <atomic> 头文件中。它为一个普通的(非原子的)对象提供原子操作的能力,而不需要改变对象本身的类型。
std::atomic<T> 需要把对象声明为原子类型,所有访问都是原子的。而 std::atomic_ref<T> 可以对一个普通变量临时施加原子操作——只在需要并发访问时使用原子操作,其余时间用普通方式访问,避免不必要的同步开销。
#include <atomic>
int counter = 0; // 普通变量
// 需要原子操作时,创建 atomic_ref
std::atomic_ref<int> ref(counter);
ref++; // 原子递增atomic_ref vs atomic
| 特性 | std::atomic_ref | std::atomic |
|---|---|---|
| 对象类型 | 引用普通对象 | 对象本身是原子的 |
| 创建时机 | 按需创建 | 声明时确定 |
| 性能 | 只在需要时有同步开销 | 所有访问都有开销 |
| 拷贝原对象 | 不拷贝(引用) | 拷贝初始值 |
| 生命周期 | 不能超过被引用对象 | 独立 |
| 适用场景 | 部分代码需要原子访问 | 全程需要原子访问 |
基本示例
#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 保持一致。