C / C++ / 系统课时

计数器为什么适合用atomic

计数器为什么适合用atomic

多个线程只需要对同一个整数做加一、减一或读取时,std::atomic 能把“读—改—写”变成不可被其他线程拆开的原子操作。本节用同一计数任务对比普通整数的数据竞争与原子计数,并说明它适合什么、不适合什么。

学习目标

  • 识别普通共享整数执行 ++ 时产生的数据竞争
  • 使用 std::atomic<int> 完成稳定的多线程计数
  • 判断何时应使用原子变量,何时仍需要互斥锁

普通整数的问题不是“偶尔少加一次”

表达式 ++counter 看起来只有一行,但对普通整数而言通常要经历读取旧值、计算新值、写回内存。两个线程可能同时读取相同旧值,再分别写回相同新值,从而发生更新丢失。

更关键的是,C++ 内存模型把多个线程在没有同步的情况下并发读写同一个普通对象定义为数据竞争,而数据竞争会导致未定义行为。因此不能把“最终值偶尔偏小”当作它唯一可能的表现,也不能依赖某次测试刚好得到正确结果。

用atomic完成最小计数

下面的程序保留一个普通计数器作为反例,并提供原子计数模式。原子模式使用 fetch_add,每次加一都作为一个不可分割的原子读改写操作完成。

cpp
#include <atomic>
#include <iostream>
#include <string>
#include <thread>
#include <vector>

constexpr int kThreads = 8;
constexpr int kPerThread = 100000;

int plain_counter = 0;
std::atomic<int> atomic_counter{0};

void add_plain() {
    for (int i = 0; i < kPerThread; ++i) {
        ++plain_counter;  // 多线程并发执行会产生数据竞争
    }
}

void add_atomic() {
    for (int i = 0; i < kPerThread; ++i) {
        atomic_counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cerr << "usage: ./counter atomic|race\n";
        return 1;
    }

    const std::string mode = argv[1];
    if (mode != "atomic" && mode != "race") {
        std::cerr << "unknown mode\n";
        return 1;
    }

    const auto task = (mode == "atomic") ? add_atomic : add_plain;
    std::vector<std::thread> threads;

    for (int i = 0; i < kThreads; ++i) {
        threads.emplace_back(task);
    }
    for (auto& thread : threads) {
        thread.join();
    }

    if (mode == "atomic") {
        std::cout << "counter=" << atomic_counter.load() << '\n';
    } else {
        std::cout << "counter=" << plain_counter << '\n';
    }
}

编译并先运行可验证的原子版本:

bash
g++ -std=c++17 -O2 -pthread counter.cpp -o counter
./counter atomic

预期输出:

text
counter=800000

八个线程各执行十万次递增,因此原子版本的最终结果稳定为 800000。这里使用 memory_order_relaxed,因为计数器只负责记录数值,不承担发布其他共享数据的同步职责。

再运行竞态版本只用于观察错误写法:

bash
./counter race

预期结果:

text
counter=<VALUE>

<VALUE> 是一次实际运行观察到的值,可能等于 800000,也可能不是;由于程序已经发生数据竞争,它没有可依赖的语言级结果。反例的意义是确认“普通整数不能这样共享”,而不是统计它通常会丢多少次更新。

atomic适合的是单变量原子状态

std::atomic 最适合计数器、标志位、引用计数、序号等“一个原子对象就能表达完整状态”的场景。它能保证该对象的读取、写入或读改写操作不会与其他线程对同一原子对象的数据访问形成数据竞争。

但原子性不会自动扩展到多个变量。例如“余额减一且库存减一必须同时成功”包含两个状态的一致性约束,即使两个字段分别都是 atomic,也无法让这两个操作整体成为一个事务。

为什么这里不需要更强的内存序

本例只要求所有递增最终被计入,线程之间不需要借计数器传递其他数据,所以 memory_order_relaxed 已足够保证 fetch_add 本身的原子性。

如果某个原子标志还承担“某线程写完数据后通知另一个线程读取”的职责,就涉及线程间可见性与先后关系,不能仅凭“它是 atomic”就机械地使用 relaxed。选择内存序时,先问这个原子变量是否只保存自身状态,还是还承担了发布和获取其他共享数据的同步职责。

对于单纯共享计数,原子变量能以很小的代码成本消除数据竞争;一旦需要维护多个状态之间的一致关系,就应把问题提升为临界区设计,而不是继续堆叠更多 atomic。

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

目录与阅读设置

阅读设置

17

记录一个想法

计数器为什么适合用atomic

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

登录哪都通