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 保护复合状态的对比图

这说明判断是否需要锁时,不能只数“有没有数据竞争”,还要检查是否存在必须整体成立的状态约束。

用程序观察不一致快照

下面的示例先刻意让读线程停在两个 atomic 写入之间,从而稳定展示不一致状态;随后用一把 mutex 把两个字段的更新与读取都放入同一个临界区。

cpp
#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();
}

预期输出

text
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”,而是“业务要求的一次完整状态变化能否由一个原子操作表达”。如果答案是否定的,用明确的互斥临界区通常更容易证明正确,也更容易维护。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

atomic能不能替代一把锁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通