C++ atomic原子操作详解_C++无锁编程与线程安全变量_技术教程

原子操作是不可分割的操作，C++11通过std::atomic提供原子类型支持无锁编程，确保多线程下变量访问安全，如atomic避免竞态条件；常用操作包括load、store、exchange和compare_exchange_weak/strong等，配合内存序（如memory_order_acquire/release）控制读写顺序，实现高效同步；示例中用CAS构建无锁队列，但需注意ABA问题与内存回收，且仅trivially copyable类型可作原子类型，合理选择内存序以平衡性能与正确性。

在多线程编程中，数据竞争是常见问题。当多个线程同时读写同一变量时，如果没有正确同步，程序行为将不可预测。C++11 引入了 std::atomic 类型，为开发者提供了高效的原子操作支持，无需使用互斥锁即可实现线程安全的变量访问。这正是无锁编程（lock-free programming）的核心基础之一。

什么是原子操作？

原子操作是指一个操作在执行过程中不会被其他线程中断，整个过程要么全部完成，要么完全不发生。例如对一个 atomic 变量进行自增操作，在底层会被编译为一条原子指令（如 x86 的 LOCK XADD），确保即使多个线程同时调用，结果也不会出错。

对比普通变量：

int value = 0;

多个线程执行 value++ 会导致竞态条件。而使用：

std::atomic value{0};

则每个操作都是原子的，线程安全。

常用原子操作与成员函数

std::atomic 提供了一系列成员函数来执行不同的原子操作：

load()：原子地读取当前值
store(val)：原子地写入新值
exchange(val)：设置新值并返回旧值
compare_exchange_weak(expected, desired) 和 compare_exchange_strong(expected, desired)：比较并交换（CAS），用于实现无锁算法的关键操作
fetch_add(), fetch_sub(), fetch_or() 等：原子地进行运算并返回原值

示例：

std::atomic counter{0};
counter.fetch_add(1); // 原子加1，返回加之前的值
int old = counter.exchange(10); // 设置为10，返回之前值

内存序（Memory Order）详解

原子操作不仅保证操作本身不可分割，还控制着内存访问的顺序。C++ 提供了六种内存序选项，影响性能和可见性：

memory_order_relaxed：最弱约束，只保证原子性，不保证顺序。适合计数器等场景
memory_order_acquire：用于 load 操作，保证此后所有读写不会被重排到该操作之前
memory_order_release：用于 store 操作，保证此前所有读写不会被重排到该操作之后
memory_order_acq_rel：结合 acquire 和 release，用于 read-modify-write 操作
memory_order_seq_cst：默认选项，提供顺序一致性，最安全但可能稍慢

举例说明 acquire/release 配合使用：

std::atomic ready{false};
int data = 0;

// 线程1：
data = 42;
ready.store(true, std::memory_order_release); // 保证 data 写入在 store 之前完成

// 线程2：
while (!ready.load(std::memory_order_acquire)) { / 等待 / }
// 此时能安全读取 data == 42

这里通过内存序确保了 data 的写入对线程2可见。

无锁编程实战：简单的无锁队列

利用原子指针可以实现基本的无锁单生产者单消费者队列：

struct Node {
int value;
Node* next;
};

std::atomic head{nullptr};

void push(int val) {
   Node* new_node = new Node{val, nullptr};
   new_node->next = head.load();
   while (!head.compare_exchange_weak(new_node->next, new_node)) {
     // 如果 head 被其他线程修改，则重试
   }
}

int pop() {
   Node* old_head = head.load();
   while (old_head && !head.compare_exchange_weak(old_head, old_head->next)) {
     // 重试直到成功
   }
   if (old_head) {
     int val = old_head->value;
     delete old_head;
     return val;
   }
   throw std::runtime_error("empty");
}