C / C++ / 系统课时
atomic能不能替代一把锁
atomic能不能替代一把锁
std::atomic 很适合保护单个计数器、标志位或指针,但“每个字段都原子”并不代表一组字段能作为整体保持一致。当业务约束跨越多个共享变量时,需要关注的是整个状态转换,而不是每次单独读写是否原子。
学习目标
- 判断单个原子操作与复合业务不变量之间的区别
- 识别多个 atomic 字段仍可能出现的不一致快照
- 根据共享状态范围选择 atomic 或 mutex
原子性不会自动扩展到多个变量
假设共享状态包含 used 和 capacity,并要求始终满足 used <= capacity。即使两个字段都是 std::atomic<int>,分别修改它们仍然是两个独立操作。
如果更新线程先把 used 从 10 改成 20,再把 capacity 从 10 改成 20,另一个线程完全可能在两次写入之间观察到 used=20, capacity=10。每一次访问都合法且原子,但组合状态违反了业务不变量。

这说明判断是否需要锁时,不能只数“有没有数据竞争”,还要检查是否存在必须整体成立的状态约束。
用程序观察不一致快照
下面的示例先刻意让读线程停在两个 atomic 写入之间,从而稳定展示不一致状态;随后用一把 mutex 把两个字段的更新与读取都放入同一个临界区。
#include <atomic>
#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
std::atomic<int> atomic_used{10};
std::atomic<int> atomic_capacity{10};
std::atomic<int> phase{0};
struct State {
int used = 10;
int capacity = 10;
};
State state;
std::mutex state_mutex;
std::atomic<bool> writer_has_lock{false};
int main() {
std::cout << std::boolalpha;
std::thread atomic_writer([] {
atomic_used.store(20, std::memory_order_relaxed);
phase.store(1, std::memory_order_release);
// 等待读线程在两个字段的更新之间完成一次快照。
while (phase.load(std::memory_order_acquire) != 2) {
std::this_thread::yield();
}
atomic_capacity.store(20, std::memory_order_relaxed);
});
std::thread atomic_reader([] {
while (phase.load(std::memory_order_acquire) != 1) {
std::this_thread::yield();
}
int used = atomic_used.load(std::memory_order_relaxed);
int capacity = atomic_capacity.load(std::memory_order_relaxed);
std::cout << "atomic snapshot: used=" << used
<< ", capacity=" << capacity
<< ", valid=" << (used <= capacity) << '\n';
phase.store(2, std::memory_order_release);
});
atomic_writer.join();
atomic_reader.join();
std::thread locked_writer([] {
std::lock_guard<std::mutex> lock(state_mutex);
state.used = 20;
writer_has_lock.store(true, std::memory_order_release);
// 即使更新过程被延长,读线程也无法进入同一临界区。
std::this_thread::sleep_for(std::chrono::milliseconds(20));
state.capacity = 20;
});
std::thread locked_reader([] {
while (!writer_has_lock.load(std::memory_order_acquire)) {
std::this_thread::yield();
}
std::lock_guard<std::mutex> lock(state_mutex);
std::cout << "mutex snapshot: used=" << state.used
<< ", capacity=" << state.capacity
<< ", valid=" << (state.used <= state.capacity) << '\n';
});
locked_writer.join();
locked_reader.join();
}预期输出
atomic snapshot: used=20, capacity=10, valid=false
mutex snapshot: used=20, capacity=20, valid=true这里的 phase 和 writer_has_lock 只用于控制演示顺序。真实业务中通常不会故意制造这种停顿,但在高并发下,同类交错完全可能自然发生。
哪些情况 atomic 更合适
当正确性只依赖一次原子操作,或者可以用一个原子的 read-modify-write 表达完整状态变化时,atomic 往往比互斥量更直接。例如独立请求计数器可以使用 fetch_add,停止标志可以使用单个布尔原子变量。
即使使用 compare-exchange 循环,也应确认“完整状态”确实装在同一个原子对象中。把三个有关联的字段分别换成三个 atomic,并不会自动获得三字段事务。
哪些情况应该保留 mutex
当多个字段需要一起修改、一起校验或一起读取时,mutex 往往能更直接地表达临界区边界。典型场景包括账户余额与流水状态同步更新、队列内容与长度元数据共同维护,以及对象多个成员必须满足同一个不变量。
锁的价值不仅是阻止两个线程同时写同一地址,还在于把一组操作定义成其他线程不可穿插观察的整体。只要所有相关访问都遵守同一把 mutex,读线程就不会看到临界区中尚未完成的中间状态。
判断 atomic 能否替代锁时,最实用的问题不是“这些字段能否声明成 atomic”,而是“业务要求的一次完整状态变化能否由一个原子操作表达”。如果答案是否定的,用明确的互斥临界区通常更容易证明正确,也更容易维护。