C++ 多线程同步：原子操作（atomic）实战

这段代码虽然能保证线程安全，但每次加锁解锁都会带来额外开销。原子操作可以在无锁的情况下实现同样的效果，且效率更高。

C++ 标准库中的原子操作

C++11 标准库在 <atomic> 头文件中提供了 std::atomic 模板类。它可以将普通类型包装成原子类型，支持原子化的读、写、修改操作。

std::atomic 的核心特性

1. 无锁同步：原子操作通过 CPU 指令级别的支持实现同步，不需要操作系统介入上下文切换。
2. 不可分割性：原子操作的执行过程不会被其他线程打断，要么完全执行，要么完全不执行。
3. 模板化设计：std::atomic 是模板类，可以包装大多数基本数据类型，如 int、bool、long 等。

常用原子操作接口

以 std::atomic<int> 为例，常用接口如下：

• 赋值与读取：支持直接用 = 赋值，用 load() 读取值，默认是顺序一致的内存序。
• 自增自减：fetch_add()（原子自增）、fetch_sub()（原子自减），返回操作前的值。
• 复合操作：exchange()（原子交换值）、compare_exchange_weak()（比较并交换）。
• 简化操作：支持 ++、--、+=、-= 等重载运算符，使用更便捷。

核心结论：原子操作的重载运算符（如 ++）是对 fetch_add() 的封装，使用起来和普通变量几乎一致。

原子操作实战：替代互斥锁解决简单同步问题

我们使用 std::atomic<int> 改造上述例子，实现无锁同步：

#include <iostream>
#include <thread>
#include <atomic>

using namespace std;

atomic<int> count(0); // 定义原子类型变量

void increment() {
    for (int i = 0; i < 100000; ++i) {
        count++; // 原子自增操作，无需加锁
    }
}

int main() {
    thread t1(increment);
    thread t2(increment);
    t1.join();
    t2.join();
    cout << "最终 count 值：" << count << endl;
    return 0;
}

运行该程序，最终 count 的值稳定等于 200000。和互斥锁版本相比，这段代码不仅更简洁，而且执行效率更高。

原子操作的内存序

std::atomic 的操作可以指定内存序，用来平衡性能和同步强度。常用的内存序有三种：

1. memory_order_seq_cst：顺序一致内存序，最强的同步保证，也是默认值。
2. memory_order_acquire/release：适用于生产者 - 消费者模型，保证操作的先后顺序。
3. memory_order_relaxed：松散内存序，仅保证操作的原子性，不保证顺序，性能最优。

示例：使用松散内存序优化自增操作

void increment() {
    for (int i = 0; i < 100000; ++i) {
        count.fetch_add(1, memory_order_relaxed);
    }
}

在只需要保证原子性的场景下，松散内存序可以显著提升性能。

原子操作 vs 互斥锁：适用场景对比

选型技巧：

• 简单变量同步（如计数器、标志位）→ 优先使用原子操作
• 复杂临界区（如多变量操作、函数调用）→ 必须使用互斥锁

实战案例 1：原子标志位实现线程退出控制

原子布尔类型 std::atomic<bool> 常用于实现线程的安全退出控制：

#include <iostream>
#include <thread>
#include <atomic>
#include <chrono>

using namespace std;

atomic<bool> is_running(true); // 原子标志位

void worker() {
    while (is_running.load()) { // 原子读取标志位
        cout << "线程正在运行..." << endl;
        this_thread::sleep_for(chrono::milliseconds(500));
    }
    cout << "线程安全退出" << endl;
}

int main() {
    thread t(worker);
    this_thread::sleep_for(chrono::seconds(2));
    is_running = false; // 原子赋值，通知线程退出
    t.join();
    cout << "主线程结束" << endl;
    return 0;
}

运行效果：线程运行 2 秒后，检测到标志位变为 false，安全退出。这个场景用原子操作比互斥锁更轻量、更高效。

实战案例 2：原子计数器实现多线程任务统计

使用原子操作实现多线程任务完成情况的统计，无需加锁：

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

using namespace std;

const int TASK_COUNT = 10;
atomic<int> completed_tasks(0); // 已完成任务数

void task(int id) {
    cout << "任务" << id << "开始执行" << endl;
    this_thread::sleep_for(chrono::milliseconds(300));
    completed_tasks++; // 原子自增，统计完成数
    cout << "任务" << id << "执行完毕" << endl;
}

int main() {
    vector<thread> threads;
    for (int i = 1; i <= TASK_COUNT; ++i) {
        threads.emplace_back(task, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    cout << "所有任务执行完毕，总计完成：" << completed_tasks << "个" << endl;
    return 0;
}

运行该程序，最终输出的完成任务数一定等于 10。这个案例充分体现了原子操作在简单统计场景下的优势。

原子操作的常见误区

1. 忽略内存序的影响 在多线程通信场景下，随意使用松散内存序可能导致程序行为异常。新手建议优先使用默认的顺序一致内存序，熟悉后再优化。
2. 认为原子操作一定比互斥锁快 在高竞争场景下，原子操作的自旋等待可能导致 CPU 占用过高。此时互斥锁的阻塞机制反而更高效。
3. 误用原子操作保护复杂逻辑 原子操作只能保证单个操作的原子性，不能保护多个原子操作的组合。例如：

// 错误示例：这两个原子操作的组合不是原子的
if (count < 100) {
    count++;
}

这个逻辑可能被多个线程打断，需要互斥锁来保护。

总结

1. 原子操作是轻量级同步方案，通过 CPU 指令级支持实现无锁同步，适用于单个变量的同步场景。
2. std::atomic 是 C++ 标准库的原子类型模板，支持自增、自减、交换等常用原子操作。
3. 原子操作和互斥锁各有适用场景：简单变量用原子操作，复杂临界区用互斥锁。
4. 原子操作的内存序可以平衡性能和同步强度，新手建议先使用默认的顺序一致内存序。