C++

C++ std::atomic 精讲

一、为什么需要 atomic:从数据竞争说起

原子操作 = 不可分割的操作:要么全部执行完,要么完全不执行,不会出现”执行到一半被打断”的中间状态。

无原子操作则存在数据竞争问题:C++ 标准规定:多线程无同步地访问同一变量且至少有一个是写,就是未定义行为。

两种解法对比

方案写法代价
std::mutexlock() / unlock() 包住可能阻塞、上下文切换,有竞争时开销大
std::atomic++counter;硬件级原子操作,不阻塞
#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> counter(0);

void increment(int n) {
    for (int i = 0; i < n; ++i)
        ++counter;                       // 原子操作,线程安全
}

int main() {
    std::thread t1(increment, 100000);
    std::thread t2(increment, 100000);
    t1.join(); t2.join();
    std::cout << counter << std::endl;   // 恒为 200000
}

为什么换成 std::atomic<int> 就安全了? 同样的 ++counter,编译器会把它变成一个不可分割的原子”读+改+写”操作,中间插不进其他线程。这就是 atomic 的核心价值。


二、基本用法

2.1 支持的类型

类型说明
整型:int、long、unsigned 系列功能最全:++、fetch_add、位运算都支持
bool最常用:标志位、开关
指针 T*支持 fetch_add(1)(移动一个 T 的长度)
自定义类型 atomic<T>要求 T 可平凡复制;只能 load/store,不能 ++(了解即可)

浮点数 float / double 要 C++20 才支持原子运算。

2.2 常用接口

std::atomic<int> counter{0};

counter.load();           // 读
counter.store(42);        // 写
counter.exchange(100);    // 设为 100,返回旧值

counter.fetch_add(1);     // 原子 +1,返回【加之前】的旧值
++counter;                // 返回【加之后】的新值(注意区别)

counter.fetch_sub(1);     // 原子 -1

2.3 比较并交换(CAS)

std::atomic<int> counter(100);

int expected = counter.load();
bool ok = counter.compare_exchange_strong(expected, 999);
//  while(counter.load() == expected)
//      bool ok = counter.compare_exchange_weak(expected, 999);
//
    含义:如果 counter == expected(说明没人动过),就改成 999,返回 true
    如果 counter != expected(别人改过了),返回 false, 并把 expected 自动更新为 counter 的当前值

CAS 回答的问题是:“从我看到它到我要改它,这期间有没有别人动过?” 没人动过才允许写数据,相当于把”检查 + 修改”合并成了一次原子操作(对比第四章的 balance 反例)。

weak 和 strong 怎么选? 放在循环里用 weak,单次判断用 strong。weak 在某些平台上可能”条件满足也返回失败”,循环场景下多转一圈就行,速度更快。

2.4 两个小注意点

std::atomic<int> a(0);
// std::atomic<int> b = a;    // ❌ 原子变量禁止拷贝和移动
std::atomic<int> b;
b.store(a.load());            // ✅ 只能 load 出来再存进去

含 atomic 成员的类也就没有默认拷贝构造——放进容器或按值传参前要想一下。


三、内存序:共有六档,这里只讲三档

每个原子操作可以带一个 memory_order_* 参数,控制”这个操作前后的代码允许被重排到什么程度”。约束越弱越快,越强越安全。

初学者记住这三档就够了:

内存序一句话理解典型场景
relaxed只保证这个操作本身原子,其他什么都不管纯计数、统计
acquire / release(成对)release 之前的所有写入,acquire 之后都能看到标志位发布数据、锁
seq_cst默认值,最强最安全拿不准就用它

3.1 release / acquire:必会的”存储-载入”模型

std::atomic<bool> ready(false);
int data = 0;    // 普通变量,不是 atomic

// 线程 1(生产者)
data = 42;                                     // ① 先写数据
ready.store(true, std::memory_order_release);  // ② 再置标志

// 线程 2(消费者)
while (!ready.load(std::memory_order_acquire)) // ③ 等标志
    ;
// ④ 这里保证读到 data == 42

记忆口诀:

release:“我之前写的所有东西,都准备好了”(存储) acquire:“看到标志的那一刻,之前的写入我全都能看到”(载入)

关键点:data 是普通变量也安全——一个 atomic 标志位就能安全发布一大片普通数据,这是这套配对的价值。顺序反了(先 release 置标志、后写数据)就没有这个保证,所以”先写数据、再置标志”这个顺序不能乱。

3.2 简略介绍 relaxed 与 seq_cst

  • relaxed:适合事件计数这类场景——只关心最终总数对,不关心它和其他变量的先后关系。好处是比默认的 seq_cst 快不少。
  • seq_cst:默认值,保证所有线程对所有 seq_cst 类型的原子操作的先后顺序看法一致。

注意它也不是魔法:线程 1 刚写完,线程 2 并不保证”立刻”读到新值,仍可能读到旧值——并发程序的正确性靠的是设计好同步点(join、condition_variable、acquire/release 配对),而不是光把变量改成 atomic 就万事大吉。

专业的说,它只保证 seq_cst 类型的内存操作对于所有线程存在全局顺序一致性,但不保证某个操作在这个串行化里排在哪,所以它无法限制并发线程的执行时序交错。详细踩坑可见 three threads with two false 场景(此篇文档按下不表)。

  • 另外还有个 acq_rel(读改写操作两头都管,如自旋锁内部),知道名字即可。

四、atomic vs mutex:应用场景选择 + 经典误区

4.1 选型表

场景选择
单个计数器 / 标志位✅ atomic
多个变量要一起改(如转账:A 减 B 加)✅ mutex(atomic 做不到)
复杂数据结构(链表、树、哈希表)✅ mutex
临界区长、含 I/O✅ mutex(atomic 会干等)
临界区极短、对延迟敏感✅ atomic

一句话总结:atomic 只保护”一个变量的一次操作”;只要逻辑跨越多个变量或多个步骤,就用 mutex。

4.2 高频误区:check-then-act 不是原子的

// ❌ 错误:以为 atomic 能保护这段逻辑
std::atomic<int> balance(100);

void withdraw(int amount) {
    if (balance.load() >= amount) {              // ① 检查
        balance.store(balance.load() - amount);  // ② 扣款
    }
}

① 和 ② 是两次独立的原子操作,中间的空隙别的线程可以插进来——两个线程同时通过检查,就双双超额扣款。

正确写法:用 CAS 把”检查 + 扣款”合并成一次原子操作:

// ✅ CAS 循环
void withdraw(int amount) {
    int expected = balance.load();
    while (expected >= amount) {
        if (balance.compare_exchange_weak(expected, expected - amount))
            break;   // 成功:说明整个期间没人动过,安全扣款
        // 失败:expected 已被自动更新为最新值,循环重新检查
    }
}

这个”CAS + 循环重试”的模式非常重要,下一章展开。


五、性能量级(心里有数即可)

操作单次延迟量级
普通 int 读写~1 ns
atomic 操作~几 ns
mutex 无竞争~几十 ns
mutex 高竞争(触发上下文切换)微秒级,且不稳定

两个结论:

  1. atomic vs mutex 的差距在竞争下拉开:atomic 永远是纳秒级常数;mutex 一旦多线程抢锁,可能陷入内核、线程切换,慢百倍以上。
  2. atomic 也不是免费的:默认的 seq_cst 比普通读写慢几倍,热点路径上显式选 relaxed 能省回来。

六、工程实践:高频的6个场景

6.1 CAS 循环:无锁编程的万能模板

思想:乐观地尝试”读 → 算 → 写”,写的时候用 CAS 确认没人动过;被人抢先了就拿到最新值重试。

std::atomic<int> var;

void update() {
    int expected = var.load();                       // ① 读旧值
    do {
        int desired = expected * 2;                  // ② 基于旧值算新值(纯计算)
    } while (!var.compare_exchange_weak(expected, desired));  // ③ 没人动过才提交
}

两个注意点:

  • 失败时 expected 自动变最新值,所以循环体不用重新 load;
  • 循环体里只放纯计算,别放有副作用的操作(new、打日志),否则重试会重复执行。

6.2 原子 ID 生成器:fetch_add 返回旧值

std::atomic<uint64_t> next_id{0};

uint64_t gen_id() {
    return next_id.fetch_add(1, std::memory_order_relaxed);
    // 第一个调用者拿 0,第二个拿 1……每人拿到不重复的 ID
}

比”锁 + 计数器”简洁且更快,统计计数同理都用 relaxed。

6.3 优雅退出标志:atomic\ 最常见的用法

std::atomic<bool> running{true};

void worker() {
    while (running) {        // 每轮循环看一眼标志
        // ... 处理任务 ...
    }
}

int main() {
    std::thread t(worker);
    // ... 
    running = false;         // 通知退出
    t.join();
}

考察点:为什么不能用普通 bool?——数据竞争是 UB,而且编译器可能发现循环里没人改 running,把它优化成死循环。atomic<bool> 同时解决这两个问题。

6.4 自旋锁:理解锁的本质

class SpinLock {
    std::atomic_flag flag_{};
public:
    void lock() {
        while (flag_.test_and_set(std::memory_order_acquire));  // 抢不到就自旋
    }
    void unlock() {
        flag_.clear(std::memory_order_release);                 // 释放并发布
    }
};

test_and_set 原子地”读旧值 + 置 true”:读出 false 说明抢锁成功。acquire/release 配对保证临界区里的数据修改对下一个拿锁的线程可见——锁的本质就是 acquire/release,这个说法在面试里很加分。

使用纪律:临界区必须极短、不能有 I/O,否则自旋的线程白烧 CPU;这种场景该用 mutex 让出 CPU。

6.5 线程安全单例:标准答案两步走

首选:Meyers 单例(C++11 起标准保证局部 static 初始化线程安全,一行搞定):

Singleton& instance() {
    static Singleton inst;   // C++11 保证:多线程同时首次调用也只构造一次
    return inst;
}

加分项:能讲清 DCLP(双重检查锁定,新标准下已弃用)为什么需要 atomic:

Singleton* p = inst_.load(std::memory_order_acquire);   // 无锁快路径
if (p == nullptr) {
    std::lock_guard<std::mutex> lk(mtx_);               // 加锁慢路径
    p = inst_.load(std::memory_order_relaxed);
    if (p == nullptr) {
        p = new Singleton;
        inst_.store(p, std::memory_order_release);      // 构造完成后才发布指针
    }
}

关键在 release/acquire:没有它们,new Singleton 的构造过程可能被重排到指针赋值之后,别的线程拿到非空指针时对象还没构造完。回答模板:“先说 Meyers 单例够用,再补一句 DCLP 的坑在指令重排、要用 atomic 的 acquire/release 修复”

6.6 shared_ptr 的线程安全性:超高频

分两层回答,千万别混:

操作线程安全?原因
不同线程各自操作自己的副本(拷贝、析构指向同一对象的 shared_ptr)✅引用计数的增减是原子操作
多个线程同时读写同一个 shared_ptr 对象❌计数原子 ≠ 指针本身原子,需要 mutex 或 C++20 的 atomic<shared_ptr>

一句话:“shared_ptr 的引用计数是原子的,但 shared_ptr 变量本身不是”。

6.7 误用清单(review 代码时对照用)

  1. volatile ≠ atomic:volatile 只禁止编译器把变量缓存到寄存器,不保证原子性,多线程同步用它仍是 UB。这是面试最爱挖的坑。
  2. check-then-act 竞态:if (a.load() > 0) a.store(a.load() - 1) 不是原子的,复合逻辑合并成一次 CAS(见 4.2)。
  3. 跨变量顺序:“先写数据、再置标志”必须用 release/acquire;两个都写 relaxed 就没有先后保证。
  4. fetch_add 返回旧值:int x = counter.fetch_add(1); 拿到的是加之前的值;要新值写 ++counter。
  5. 默认参数的开销:不写内存序就是 seq_cst,最安全也最贵;纯计数记得显式 relaxed。

七、速答卡

问题30 秒答案
atomic 解决什么问题?数据竞争:保证单次操作的原子性,并按内存序保证可见性,不需要锁。
counter++ 为什么不安全?读-加-写三步会被其他线程打断,造成丢失更新;atomic 把三步合并为不可分割的操作。
atomic 和 mutex 怎么选?单变量的简单读写/计数用 atomic;多变量复合操作、复杂结构、长临界区用 mutex。
CAS 是什么?Compare-And-Swap:值还等于我看到的旧值才写入新值,否则失败。配合循环重试实现”逻辑上的原子”。
weak 和 strong CAS 区别?循环里用 weak(可能伪失败但更快),单次判断用 strong。失败时 expected 自动更新为最新值。
内存序常用哪三档?relaxed(纯计数)、acquire/release(成对,发布-订阅)、seq_cst(默认,拿不准就用)。
acquire/release 什么含义?release:“我之前的写入都已就绪”;acquire:“看到标志后,之前的写入我全可见”。
volatile 能替代 atomic 吗?不能。volatile 只防编译器优化,不保证原子性和顺序,多线程同步用它仍是 UB。
shared_ptr 线程安全吗?引用计数是原子的(各线程操作各自的副本安全);但同一个 shared_ptr 对象的并发读写不安全。
线程安全单例怎么写?首选 Meyers(局部 static,C++11 保证安全);DCLP 需 atomic 指针 + release/acquire 防构造重排。

附:进阶导引

如果面试官聊到无锁容器/无锁栈,记住一个关键词就够了——ABA 问题:CAS 只比较”值一样”,不比较”历史”,地址被 A→B→A 折腾过之后 CAS 会误判”没变过”;工业界的解法是给指针带版本号或延迟内存回收。被问到时答出”知道有这回事 + 关键词”,比硬撑着展开要稳。

参考:cppreference - std::atomic、《C++ Concurrency in Action》第 5 章