原子操作与内存模型
当多个线程共享数据时,互斥锁是最直接的方案,但有时候代价太高。原子操作(atomic operations)让你在无锁条件下安全地读写共享变量——前提是你理解内存模型的规则。本章从基础用法讲起,逐步深入到内存序的选择策略。
学习建议:初学者先掌握 std::atomic 的基本用法和默认内存序 seq_cst。内存序的精细控制属于高级优化,不必一开始就追求 relaxed 写法。
1. std::atomic 基础
std::atomic<T> 将对变量的操作变为"不可分割"的原子操作——中间状态对其他线程不可见。它位于 <atomic> 头文件中。
基本声明与操作
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
std::atomic<int> counter{0}; // 原子整数,初始值为 0
void increment(int times) {
for (int i = 0; i < times; ++i) {
counter++; // 原子自增,等价于 counter.fetch_add(1)
}
}
int main() {
std::vector<std::jthread> threads;
for (int i = 0; i < 10; ++i) {
threads.emplace_back(increment, 10000);
}
threads.clear(); // 等待所有线程结束
std::cout << "counter = " << counter.load() << "\n";
// 输出: counter = 100000(保证精确)
}
如果用普通 int 替换 std::atomic<int>,结果将是未定义行为——多线程同时写同一变量是数据竞争。
核心成员函数
std::atomic<int> val{42};
// load() — 原子读取
int x = val.load(); // 读取当前值
int y = val.load(std::memory_order_relaxed); // 指定内存序
// store() — 原子写入
val.store(100); // 写入新值
val.store(200, std::memory_order_release);
// exchange() — 原子交换,返回旧值
int old = val.exchange(999); // old == 200, val == 999
// 运算符重载(使用默认 seq_cst 内存序)
val = 50; // 等价于 val.store(50)
int z = val; // 等价于 val.load()
lock-free 检查
std::atomic<int> ai;
std::atomic<double> ad;
// 检查是否真正无锁(硬件直接支持)
static_assert(std::atomic<int>::is_always_lock_free);
std::cout << "int lock-free: " << ai.is_lock_free() << "\n"; // 通常为 true
std::cout << "double lock-free: " << ad.is_lock_free() << "\n"; // 平台相关
注意:std::atomic<T> 要求 T 是 trivially copyable 类型。不能对含虚函数表、自定义析构函数的类型使用原子操作。常用类型包括整数、指针、枚举和小型 POD 结构。
2. 常用原子操作
fetch_add / fetch_sub
读-改-写(Read-Modify-Write)操作,原子地执行加减并返回操作前的旧值:
std::atomic<int> count{10};
int prev = count.fetch_add(5); // prev == 10, count == 15
prev = count.fetch_sub(3); // prev == 15, count == 12
// 运算符形式(返回新值)
int now = ++count; // now == 13
now = count += 10; // now == 23
compare_exchange — CAS 操作
CAS(Compare-And-Swap)是无锁算法的核心操作。它的语义是:"如果当前值等于期望值,就替换为新值;否则把当前值写回期望值变量。"
std::atomic<int> val{100};
int expected = 100;
bool success = val.compare_exchange_strong(expected, 200);
// success == true, val == 200, expected == 100(未修改)
expected = 100; // 预期 100,但实际已经是 200
success = val.compare_exchange_strong(expected, 300);
// success == false, val == 200(未改变), expected == 200(被更新为实际值)
weak vs strong
// compare_exchange_weak 可能"虚假失败"(spurious failure)
// 即使值相等也可能返回 false,所以通常在循环中使用
std::atomic<int> val{0};
int expected = val.load();
int desired = expected + 1;
// weak 版本 — 搭配循环使用,在某些架构上更高效
while (!val.compare_exchange_weak(expected, desired)) {
desired = expected + 1; // 用更新后的 expected 重新计算
}
// strong 版本 — 不会虚假失败,适合只执行一次的场景
expected = val.load();
if (val.compare_exchange_strong(expected, 999)) {
// 成功替换
}
选择建议:循环中用 weak(性能更好),单次判断用 strong(逻辑更清晰)。
CAS 实战:无锁最大值更新
std::atomic<int> global_max{0};
void update_max(int new_val) {
int current = global_max.load(std::memory_order_relaxed);
while (new_val > current) {
// 尝试将 global_max 从 current 更新为 new_val
if (global_max.compare_exchange_weak(
current, new_val, std::memory_order_relaxed)) {
break; // 成功
}
// 失败时 current 被自动更新为最新值,循环重试
}
}
3. 内存序 (Memory Ordering)
原子操作保证了单个变量读写的完整性,但多个变量之间的可见性顺序由内存序决定。现代 CPU 和编译器会重排指令以提高性能,内存序就是控制这种重排的工具。
四种主要内存序
| 内存序 | 语义 | 使用场景 |
|---|---|---|
seq_cst |
所有线程看到一致的全局操作顺序 | 默认选择,最安全 |
acquire |
当前 load 之后的读写不会被重排到 load 之前 | 配合 release 使用,读端 |
release |
当前 store 之前的读写不会被重排到 store 之后 | 配合 acquire 使用,写端 |
relaxed |
仅保证原子性,不限制重排 | 纯计数器,无数据依赖 |
seq_cst — 顺序一致性(默认)
std::atomic<bool> x{false}, y{false};
std::atomic<int> z{0};
// 线程 A
void thread_a() {
x.store(true); // 默认 seq_cst
}
// 线程 B
void thread_b() {
y.store(true); // 默认 seq_cst
}
// 线程 C
void thread_c() {
while (!x.load()) {} // 等待 x 为 true
if (y.load()) ++z; // 如果 y 也为 true, z++
}
// 线程 D
void thread_d() {
while (!y.load()) {} // 等待 y 为 true
if (x.load()) ++z; // 如果 x 也为 true, z++
}
// seq_cst 保证:程序结束时 z 不可能为 0
// 因为所有线程观察到的 x, y 写入顺序一致
acquire-release — 建立同步点
最常用的优化模式。写端用 release,读端用 acquire,二者配对形成 happens-before 关系:
std::atomic<bool> data_ready{false};
int data = 0; // 普通变量,被原子变量"保护"
// 生产者线程
void producer() {
data = 42; // (1) 普通写
data_ready.store(true, std::memory_order_release); // (2) release 写
// release 保证: (1) 一定在 (2) 之前对其他线程可见
}
// 消费者线程
void consumer() {
while (!data_ready.load(std::memory_order_acquire)) {} // (3) acquire 读
std::cout << data << "\n"; // (4) 保证看到 data == 42
// acquire 保证: (4) 一定在 (3) 之后执行
// 配合 release: (1) happens-before (4)
}
理解 acquire-release 的关键:release store 把"之前的所有写入"打包发布,acquire load 读到该 store 时就能看到所有打包的内容。就像一个"发布-订阅"机制。
relaxed — 仅保证原子性
// 适用场景:纯计数,不需要与其他变量建立顺序关系
std::atomic<uint64_t> request_count{0};
void handle_request() {
// 只需要精确计数,不需要与其他操作同步
request_count.fetch_add(1, std::memory_order_relaxed);
}
uint64_t get_count() {
return request_count.load(std::memory_order_relaxed);
}
重要原则:先用 seq_cst 写正确的代码,通过性能分析确认原子操作是瓶颈后,再考虑用更弱的内存序优化。绝大多数应用代码不需要手动指定内存序。
4. std::atomic_flag
std::atomic_flag 是 C++ 中唯一保证无锁的原子类型。它只有 set/clear 两种状态,是实现自旋锁的理想选择。
#include <atomic>
#include <thread>
#include <iostream>
class Spinlock {
std::atomic_flag flag_ = ATOMIC_FLAG_INIT; // 初始为 clear 状态
public:
void lock() {
// test_and_set: 将 flag 设为 set, 返回旧值
// 如果旧值是 true (已被锁), 说明别人持锁, 继续自旋
while (flag_.test_and_set(std::memory_order_acquire)) {
// C++20: 可以用 wait 避免忙等
// flag_.wait(true, std::memory_order_relaxed);
}
}
void unlock() {
flag_.clear(std::memory_order_release);
// C++20: 唤醒等待的线程
// flag_.notify_one();
}
};
// 使用示例
Spinlock spin;
int shared_data = 0;
void worker(int id) {
for (int i = 0; i < 10000; ++i) {
spin.lock();
++shared_data;
spin.unlock();
}
}
int main() {
std::jthread t1(worker, 1);
std::jthread t2(worker, 2);
t1.join();
t2.join();
std::cout << "shared_data = " << shared_data << "\n"; // 20000
}
自旋锁的适用场景:仅适合临界区极短(几条指令)且竞争不激烈的情况。长时间持锁或高竞争场景应使用 std::mutex,否则自旋浪费 CPU 资源。
5. 原子操作 vs 互斥锁
| 对比维度 | 原子操作 | 互斥锁 |
|---|---|---|
| 适用操作 | 单变量的简单读写 | 多变量的复合操作 |
| 开销 | 几纳秒(硬件指令) | 几十~几百纳秒(系统调用) |
| 阻塞行为 | 无锁(或自旋) | 阻塞等待 |
| 死锁风险 | 无 | 有(嵌套加锁时) |
| 复杂度 | 正确性难验证 | 推理简单直观 |
| 典型用例 | 计数器、标志位、状态机 | 数据结构操作、I/O、多步事务 |
// 用原子操作:简单计数器
std::atomic<int> counter{0};
counter.fetch_add(1); // 一条指令搞定
// 用互斥锁:需要同时修改多个变量
std::mutex mtx;
struct Account { int balance; std::string last_op; };
Account acc{1000, ""};
void transfer(int amount) {
std::lock_guard lock(mtx);
acc.balance -= amount; // 两步操作必须是原子的整体
acc.last_op = "transfer"; // 不能只完成一步
}
经验法则:如果操作涉及单个整数/指针/布尔值的简单修改 → 原子操作。如果需要保护多个变量的一致性、执行条件判断+修改、或临界区超过几行代码 → 互斥锁。
6. C++20 原子增强
atomic_ref — 为非原子对象提供原子访问
#include <atomic>
#include <vector>
#include <thread>
struct Counters {
int hits = 0; // 普通 int,不是 atomic
int misses = 0;
};
void record_hit(Counters& c) {
// 通过 atomic_ref 对普通变量进行原子操作
std::atomic_ref<int> ref{c.hits};
ref.fetch_add(1, std::memory_order_relaxed);
}
// 优势:不需要改变数据结构的布局
// 注意:同一对象的所有并发访问都必须通过 atomic_ref
atomic<shared_ptr> — 线程安全的共享指针
#include <atomic>
#include <memory>
// C++20 之前:需要用 std::atomic_load/store 自由函数(已废弃)
// C++20:直接用 std::atomic<std::shared_ptr<T>>
std::atomic<std::shared_ptr<Config>> global_config;
// 读取线程 — 无锁读
void reader() {
auto cfg = global_config.load(); // 原子地获取一个快照
// 使用 cfg...
}
// 更新线程 — 原子替换
void updater(std::shared_ptr<Config> new_cfg) {
global_config.store(std::move(new_cfg)); // 原子地替换
}
// CAS 更新
void conditional_update() {
auto expected = global_config.load();
auto desired = std::make_shared<Config>(*expected);
desired->version++;
// 只在 config 未被其他线程修改时更新
global_config.compare_exchange_strong(expected, desired);
}
wait / notify — 原子变量上的等待
std::atomic<int> state{0};
// 等待线程
void waiter() {
state.wait(0); // 阻塞直到 state 不再是 0
// 比自旋等待更省 CPU: while (state.load() == 0) {}
std::cout << "state changed to: " << state.load() << "\n";
}
// 通知线程
void notifier() {
std::this_thread::sleep_for(std::chrono::seconds(1));
state.store(1);
state.notify_one(); // 唤醒一个等待者
// state.notify_all(); // 唤醒所有等待者
}
wait/notify 的价值:比 condition_variable 更轻量(不需要配合 mutex),比自旋等待更省 CPU。适合简单的"等待某个值变化"场景。
7. 实用模式
模式一:线程安全计数器
class ThreadSafeCounter {
std::atomic<uint64_t> count_{0};
public:
void increment() noexcept {
count_.fetch_add(1, std::memory_order_relaxed);
}
void decrement() noexcept {
count_.fetch_sub(1, std::memory_order_relaxed);
}
uint64_t get() const noexcept {
return count_.load(std::memory_order_relaxed);
}
void reset() noexcept {
count_.store(0, std::memory_order_relaxed);
}
};
模式二:改进的自旋锁(带退避)
class AdaptiveSpinlock {
std::atomic_flag flag_ = ATOMIC_FLAG_INIT;
public:
void lock() noexcept {
// 第一阶段:尝试直接获取
if (!flag_.test_and_set(std::memory_order_acquire)) {
return;
}
// 第二阶段:自旋等待(只读 test,减少缓存行争用)
int spin_count = 0;
while (flag_.test(std::memory_order_relaxed)) {
if (++spin_count > 100) {
// 超过阈值,让出 CPU
std::this_thread::yield();
spin_count = 0;
}
}
// 再次尝试获取
while (flag_.test_and_set(std::memory_order_acquire)) {
while (flag_.test(std::memory_order_relaxed)) {
std::this_thread::yield();
}
}
}
void unlock() noexcept {
flag_.clear(std::memory_order_release);
}
};
模式三:SPSC(单生产者-单消费者)标志
// 一个生产者写入数据 + 设置标志,一个消费者等待标志 + 读取数据
template<typename T>
class SPSCSlot {
T data_;
std::atomic<bool> ready_{false};
public:
// 仅由生产者调用
void publish(T value) {
data_ = std::move(value); // 先写数据
ready_.store(true, std::memory_order_release); // 再发布标志
}
// 仅由消费者调用
bool try_consume(T& out) {
if (ready_.load(std::memory_order_acquire)) { // 先读标志
out = std::move(data_); // 再读数据
ready_.store(false, std::memory_order_release);
return true;
}
return false;
}
// 阻塞版本(C++20)
T consume() {
ready_.wait(false, std::memory_order_acquire);
T result = std::move(data_);
ready_.store(false, std::memory_order_release);
return result;
}
};
模式四:原子状态机
enum class State { Idle, Starting, Running, Stopping, Stopped };
class Service {
std::atomic<State> state_{State::Idle};
public:
bool start() {
State expected = State::Idle;
// CAS: 只有从 Idle 才能转到 Starting
if (!state_.compare_exchange_strong(expected, State::Starting)) {
return false; // 当前不在 Idle 状态,启动失败
}
// 执行初始化工作...
state_.store(State::Running, std::memory_order_release);
return true;
}
bool stop() {
State expected = State::Running;
if (!state_.compare_exchange_strong(expected, State::Stopping)) {
return false;
}
// 执行清理工作...
state_.store(State::Stopped, std::memory_order_release);
return true;
}
State current_state() const noexcept {
return state_.load(std::memory_order_acquire);
}
// C++20: 等待状态变化
void wait_for_running() {
state_.wait(State::Starting, std::memory_order_acquire);
}
};
本章小结
std::atomic<T>让单个变量的读写不可被撕裂,是无锁编程的基石load/store/exchange/compare_exchange是四种核心原子操作,CAS 是无锁算法的灵魂- 内存序控制跨变量的可见性顺序:
seq_cst最安全(默认),acquire-release最常用于优化,relaxed仅用于纯计数 std::atomic_flag是唯一保证无锁的类型,适合实现轻量级自旋锁- 原子操作适合简单的单变量操作(计数器、标志位),复合操作仍应使用互斥锁
- C++20 引入了
atomic_ref、atomic<shared_ptr>和wait/notify,显著增强了原子操作的实用性 - 先正确再优化:默认用
seq_cst,只在性能关键路径且经过测量后才考虑弱内存序