C++ atomic原子操作详解_C++无锁编程与内存模型基础

原子操作是不可分割的操作，C++中通过std::atomic实现，保证多线程下共享变量的安全访问，避免数据竞争；其内存顺序模型包括memory_order_relaxed、acquire、release、acq_rel、seq_cst和consume，用于在性能与同步间权衡；典型应用有自旋锁、无锁栈等，需注意ABA问题及类型限制。

在现代多线程编程中，数据竞争（data race）是导致程序行为未定义的主要原因之一。C++ 提供了 std::atomic 来支持原子操作，使得多个线程可以安全地访问共享变量而无需显式使用互斥锁。这不仅提升了性能，还为实现无锁（lock-free）数据结构提供了基础。

什么是原子操作？

原子操作是指一个操作在执行过程中不会被其他线程中断。也就是说，该操作要么完全执行，要么完全没有执行，不存在中间状态。例如，对一个整数进行“读-修改-写”操作（如递增），如果非原子执行，可能在读和写之间被其他线程修改，造成结果错误。

使用 std::atomic 可以保证对变量的操作是原子的。常见类型包括：

• std::atomic
• std::atomic
• std::atomic
• std::atomic（指针类型）

例如：

立即学习“C++免费学习笔记（深入）”；

std::atomic counter{0};
void increment() {
for (int i = 0; i < 1000; ++i) {
counter.fetch_add(1, std::memory_order_relaxed);
}
}
// 多个线程调用 increment()，最终 counter 值为线程数 × 1000

内存顺序（Memory Order）详解

原子操作的强大之处在于它允许开发者控制内存访问的顺序，从而在性能与同步强度之间做权衡。C++ 提供了六种内存顺序选项，定义在 std::memory_order 枚举中：

腾讯AI 开放平台

腾讯AI开放平台

下载

• memory_order_relaxed：仅保证操作的原子性，不提供同步或顺序约束。适用于计数器等无需同步的场景。
• memory_order_acquire：用于读操作（如 load），确保该操作之后的读写不会被重排到此操作之前。
• memory_order_release：用于写操作（如 store），确保该操作之前的读写不会被重排到此操作之后。
• memory_order_acq_rel：同时具备 acquire 和 release 语义，常用于 read-modify-write 操作（如 fetch_add）。
• memory_order_seq_cst：最严格的顺序，提供全局顺序一致性。所有线程看到的操作顺序一致。默认选项，但性能开销最大。
• memory_order_consume：依赖于该加载的数据的后续操作不会被重排到之前。使用较少，且易出错。

典型应用示例：实现自旋锁或发布指针

std::atomic flag{false};
int data = 0;
// 线程1
void producer() {
data = 42;                                    // 非原子写
flag.store(true, std::memory_order_release);  // 保证上面的写不会被重排到后面
}
// 线程2
void consumer() {
while (!flag.load(std::memory_order_acquire)) { // 保证下面的读不会被重排到前面
// 自旋等待
}
// 此时能安全读取 data
printf("data = %d\n", data); // 输出 42
}

无锁编程（Lock-Free Programming）

当一个原子类型的操作不会导致线程阻塞（即不依赖操作系统锁），称为 lock-free。可通过 is_lock_free() 成员函数判断：

std::atomic a;
if (a.is_lock_free()) {
    // 通常是基于 CPU 原子指令（如 x86 的 LOCK 前缀）
} else {
    // 实际上可能内部用了互斥量，不是真正无锁
}

无锁队列、栈等数据结构利用 compare_exchange_weak 或 compare_exchange_strong 实现：

template
class LockFreeStack {
    struct Node {
        T data;
        Node* next;
        Node(const T& d) : data(d), next(nullptr) {}
    };
std::atomic head{nullptr};
public:
void push(const T& data) {
Node* new_node = new Node(data);
new_node->next = head.load();
while (!head.compare_exchange_weak(new_node->next, new_node)) {
// 如果 head 被其他线程修改，new_node->next 已更新为最新值，重试
}
}
bool pop(T& result) {
    Node* old_head = head.load();
    while (old_head && !head.compare_exchange_weak(old_head, old_head->next)) {
        // 重试直到成功将 head 指向下一个节点
    }
    if (old_head) {
        result = old_head->data;
        delete old_head;
        return true;
    }
    return false;
}
};

注意：compare_exchange_weak 允许偶然失败（即使值相等也可能失败），因此必须放在循环中使用；compare_exchange_strong 保证逻辑正确性，但在某些架构上略慢。
使用建议与注意事项

默认使用 memory_order_seq_cst 是安全的，但在高性能场景应根据需求降级为 relaxed、acquire/release。
避免手动实现复杂无锁结构，除非必要。优先使用标准库或成熟库（如 folly、boost.atomic）。
注意 ABA 问题：在 CAS 操作中，值从 A 变为 B 再变回 A，可能导致逻辑错误。可通过添加版本号（如 atomic
air>）解决。

不要对非平凡类型（non-trivial type）使用 atomic，如 atomic<:string> 不合法。只能用于可平凡复制（trivially copyable）类型。


基本上就这些。掌握原子操作和内存模型，是写出高效、正确并发程序的关键一步。虽然概念抽象，但通过实践和典型模式积累，能够逐步驾驭无锁编程的复杂性。