原子操作与内存模型

当多个线程共享数据时,互斥锁是最直接的方案,但有时候代价太高。原子操作(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,只在性能关键路径且经过测量后才考虑弱内存序