如何在C++中使用std::atomic进行原子操作_C++原子操作与无锁编程

原子操作通过互斥访问共享数据实现线程安全，C++中std::atomic提供原子读写能力。其核心操作包括load、store、exchange及compare_exchange_weak/strong，后者常用于无锁算法。示例中多个线程对std::atomic counter进行递增，确保结果正确为40000。内存顺序如memory_order_relaxed至memory_order_seq_cst影响同步强度与性能，需根据需求选择以平衡效率与一致性。自旋锁可用std::atomic实现，通过exchange和store配合acquire-release语义完成。使用陷阱包括伪共享、ABA问题、内存泄漏和死锁，需采用填充、版本号、Hazard Pointer等技术规避。

原子操作的核心在于保证多线程环境下对共享数据的访问是互斥的，避免数据竞争，从而实现线程安全。C++的

std::atomic

解决方案：

使用

std::atomic

• load()

  : 原子地读取值。

• store()

  : 原子地存储值。

• exchange()

  : 原子地用新值替换旧值，并返回旧值。

• compare_exchange_weak()

  和

  compare_exchange_strong()

  : 原子地比较当前值与预期值，如果相等则用新值替换，否则不替换。这两个函数是实现无锁算法的基础。

  compare_exchange_weak()

  在某些平台上可能由于伪失败（spurious failure）而返回失败，即使当前值与预期值相等，因此通常在一个循环中使用。

  compare_exchange_strong()

  则保证只有在当前值与预期值不相等时才会返回失败。

下面是一个简单的例子，展示了如何使用

std::atomic

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

#include 
#include 
#include 
#include 

std::atomic counter(0); // 初始化原子计数器

void increment_counter() {
  for (int i = 0; i < 10000; ++i) {
    counter++; // 原子递增操作
  }
}

int main() {
  std::vector threads;
  for (int i = 0; i < 4; ++i) {
    threads.emplace_back(increment_counter);
  }

  for (auto& thread : threads) {
    thread.join();
  }

  std::cout << "Counter value: " << counter << std::endl; // 预期输出：40000
  return 0;
}

在这个例子中，

counter

std::atomic

counter++

counter

无锁编程往往比基于锁的编程更加复杂，需要仔细考虑内存模型、数据一致性等问题。

std::atomic

std::atomic

std::atomic

• std::memory_order_relaxed

  : 最宽松的内存顺序，只保证操作的原子性，不保证任何同步或排序。

• std::memory_order_consume

  : 保证当前线程能够看到依赖于当前原子变量的其它原子变量的最新值。

• std::memory_order_acquire

  : 保证当前线程能够看到其它线程在释放（release）同一个原子变量之前的所有写入操作。

• std::memory_order_release

  : 保证当前线程的所有写入操作对其它线程在获取（acquire）同一个原子变量之后可见。

• std::memory_order_acq_rel

  : 同时具有 acquire 和 release 的语义，通常用于 read-modify-write 操作，例如

  fetch_add

  。

• std::memory_order_seq_cst

  : 默认的内存顺序，提供最强的同步保证，保证所有原子操作都按照一个全局的顺序执行。

选择合适的内存顺序对于性能至关重要。

std::memory_order_relaxed

std::memory_order_seq_cst

举个例子，假设有两个线程 A 和 B，共享一个原子变量

x

酷兔AI论文

专业原创高质量、低查重，免费论文大纲，在线AI生成原创论文，AI辅助生成论文的神器！

下载

x.store(1, std::memory_order_release);

线程 B 执行以下操作：

int value = x.load(std::memory_order_acquire);

在这个例子中，

std::memory_order_release

x

std::memory_order_acquire

x

x

如何使用

std::atomic

自旋锁是一种忙等待的锁，线程会不断地检查锁是否可用，直到锁被释放。使用

std::atomic

#include 

class SpinLock {
public:
  SpinLock() : locked(false) {}

  void lock() {
    while (locked.exchange(true, std::memory_order_acquire));
  }

  void unlock() {
    locked.store(false, std::memory_order_release);
  }

private:
  std::atomic locked;
};

在这个例子中，

locked

std::atomic

lock()

exchange()

locked

true

exchange()

true

locked

false

exchange()

locked

true

false

unlock()

store()

需要注意的是，自旋锁只适用于锁的持有时间很短的情况。如果锁的持有时间很长，线程会浪费大量的 CPU 时间在忙等待上。在锁的持有时间很长的情况下，应该使用互斥锁（

std::mutex

std::condition_variable

使用

std::atomic

使用

std::atomic

• 伪共享（False Sharing）: 如果多个线程访问相邻的原子变量，即使这些变量之间没有逻辑关系，也可能导致性能下降。这是因为 CPU 缓存行是以行为单位进行缓存的，如果多个线程访问同一个缓存行中的不同变量，会导致缓存行的频繁失效和重新加载。为了避免伪共享，可以将原子变量分散到不同的缓存行中，例如使用填充（padding）。
• ABA 问题: 在无锁算法中，如果一个原子变量的值从 A 变为 B，然后再变回 A，可能会导致一些问题。例如，

  compare_exchange_weak()

  可能会错误地认为原子变量的值没有改变，从而导致算法出错。为了解决 ABA 问题，可以使用版本号或指针标记。
• 内存泄漏: 在无锁数据结构中，如果一个线程在释放一个节点之前崩溃，可能会导致内存泄漏。为了避免内存泄漏，可以使用 Hazard Pointer 或 RCU（Read-Copy-Update）等技术。
• 死锁: 虽然

  std::atomic

  本身可以避免数据竞争，但如果使用不当，仍然可能导致死锁。例如，如果两个线程互相等待对方释放锁，就会导致死锁。

总之，使用

std::atomic