C++原子操作实现多线程同步基础

P粉602998670

发布时间：2025-08-21 09:30:02

881人浏览过

来源于php中文网

原创

原子操作的本质是不可分割性，它保证对共享变量的操作不会被中断，从而避免数据竞争。C++通过std::atomic提供原子类型，支持load、store、exchange、compare_exchange_weak/strong及fetch_add等操作，适用于计数、无锁算法等场景。内存顺序如memory_order_relaxed、acquire、release和seq_cst控制操作的可见性和顺序，需根据同步需求权衡性能与正确性。原子操作性能通常优于互斥锁，但复杂操作或低并发场景下应避免使用。

c++原子操作实现多线程同步基础

原子操作是C++多线程编程中实现同步的基础工具，它允许我们在没有锁的情况下安全地修改共享变量。理解和正确使用原子操作对于构建高效、无死锁的多线程应用至关重要。

使用C++原子操作实现多线程同步。

原子操作的本质是什么？为什么它能实现线程安全？

原子操作的本质是不可分割性。一个原子操作在执行过程中不会被其他线程中断。这种特性保证了对共享变量的修改要么完全完成，要么完全不发生，避免了数据竞争和不一致性。C++11引入了

<atomic>

头文件，提供了

std::atomic<T>

模板类，允许我们对基本数据类型（如

int

、

bool

、指针等）进行原子操作。

例如，考虑一个简单的计数器：

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

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

std::atomic<int> counter(0);

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

int main() {
  std::thread t1(increment_counter);
  std::thread t2(increment_counter);

  t1.join();
  t2.join();

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

在这个例子中，

counter++

实际上是一个原子操作，它等价于

counter.fetch_add(1)

。如果没有原子操作，我们可能需要使用互斥锁来保护计数器，这会带来额外的性能开销。

原子操作有哪些常见的操作类型？它们分别适用于什么场景？

std::atomic<T>

提供了多种原子操作，常见的包括：

load()
: 原子地读取变量的值。
store()
: 原子地存储一个新值到变量。
exchange()
: 原子地用一个新值替换变量的旧值，并返回旧值。
compare_exchange_weak()
和 compare_exchange_strong()
: 原子地比较变量的当前值和一个期望值，如果相等，则用一个新值替换变量。否则，将期望值更新为变量的当前值。这两种变体的区别在于，
```
weak
```
版本可能在变量值没有改变的情况下也失败（所谓的“伪失败”），而
```
strong
```
版本保证只有在变量值确实改变时才会失败。
fetch_add()
, fetch_sub()
, fetch_and()
, fetch_or()
, fetch_xor()
: 原子地进行加、减、与、或、异或操作，并返回操作前的值。

选择哪种操作取决于具体的应用场景。例如，

load()

和

store()

适用于简单的读写操作，

exchange()

适用于需要获取旧值的场景，

compare_exchange_weak()

strong()

适用于实现无锁算法，而

fetch_add()

等适用于原子计数。

compare_exchange_weak()

和

compare_exchange_strong()

经常用于实现无锁数据结构，例如无锁队列或栈。它们通过循环重试的方式，确保在并发修改的情况下也能正确地更新变量。

Cutout.Pro

AI驱动的视觉设计平台

下载

原子操作的内存顺序是什么？如何选择合适的内存顺序？

原子操作的内存顺序（Memory Order）决定了原子操作相对于其他读写操作的可见性。C++11 提供了多种内存顺序选项，包括：

std::memory_order_relaxed
: 最宽松的内存顺序，只保证原子性，不保证任何顺序性。
std::memory_order_consume
: 保证当前线程中依赖于本次读取操作的后续读取操作可以看到本次读取的结果。
std::memory_order_acquire
: 保证当前线程中后续的读取操作可以看到本次读取的结果。
std::memory_order_release
: 保证当前线程中之前的写入操作对其他线程可见。
std::memory_order_acq_rel
: 同时具有
```
acquire
```
和
```
release
```
的语义。
std::memory_order_seq_cst
: 默认的内存顺序，提供最强的顺序性保证，所有线程按照全局一致的顺序看到所有原子操作。

选择合适的内存顺序需要仔细考虑并发场景。通常情况下，

std::memory_order_seq_cst

是一个安全的选择，但它也是性能开销最高的。在某些情况下，可以使用更宽松的内存顺序来提高性能，但需要确保程序的正确性。

例如，考虑一个简单的生产者-消费者模型：

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

std::atomic<bool> data_ready(false);
std::vector<int> data;

void producer() {
  data.push_back(42);
  data_ready.store(true, std::memory_order_release);
}

void consumer() {
  while (!data_ready.load(std::memory_order_acquire)) {
    // 等待数据准备好
  }
  std::cout << "Data received: " << data[0] << std::endl;
}

int main() {
  std::thread t1(producer);
  std::thread t2(consumer);

  t1.join();
  t2.join();

  return 0;
}

在这个例子中，生产者使用