C++原子变量使用无锁编程实现方法

P粉602998670

发布时间：2025-08-20 12:10:02

631人浏览过

来源于php中文网

原创

原子变量通过std::atomic实现无锁编程，提升多线程性能，适用于简单操作，需注意ABA问题、伪共享及内存顺序选择，相比互斥锁性能更高但适用范围有限。

c++原子变量使用无锁编程实现方法

原子变量在C++中主要用于无锁编程，它允许你在多线程环境中安全地修改变量，而无需显式使用互斥锁。这可以显著提高性能，尤其是在锁竞争激烈的情况下。

解决方案

C++11引入了

<atomic>

头文件，提供了

std::atomic<T>

模板类，用于创建原子变量。以下是使用原子变量实现无锁编程的基本方法：

包含头文件:
```
#include <atomic>
```
立即学习“C++免费学习笔记（深入）”；

声明原子变量: 使用

std::atomic<T>

声明原子变量，其中

是变量的类型 (例如

int

bool

double

, 指针等)。

std::atomic<int> counter(0); // 初始化为0
std::atomic<bool> flag(false);

原子操作: 使用原子操作来修改和读取原子变量。
```
std::atomic
```
提供了以下常用的原子操作：
- ```
load()
```
  : 原子地读取变量的值。
- ```
store(value)
```
  : 原子地存储新的值到变量。
- ```
exchange(value)
```
  : 原子地将变量的值替换为新的值，并返回旧的值。
- ```
compare_exchange_weak(expected, desired)
```
  : 如果变量的当前值等于
```
expected
```
  ，则原子地将变量的值替换为
```
desired
```
  。如果不相等，则将
```
expected
```
  更新为变量的当前值。这是一个弱版本，可能虚假地失败（即使变量的值等于
```
expected
```
  ），因此通常需要在一个循环中使用。
- ```
compare_exchange_strong(expected, desired)
```
  : 与
```
compare_exchange_weak
```
  类似，但保证不会虚假地失败。性能可能比
```
compare_exchange_weak
```
  差。
- ```
fetch_add(value)
```
  : 原子地将变量的值加上
```
value
```
  ，并返回旧的值。
- ```
fetch_sub(value)
```
  : 原子地将变量的值减去
```
value
```
  ，并返回旧的值。
- ```
fetch_and(value)
```
  : 原子地将变量的值与
```
value
```
  进行按位与运算，并返回旧的值。
- ```
fetch_or(value)
```
  : 原子地将变量的值与
```
value
```
  进行按位或运算，并返回旧的值。
- ```
fetch_xor(value)
```
  : 原子地将变量的值与
```
value
```
  进行按位异或运算，并返回旧的值。
```
counter.store(10);
int oldValue = counter.load();
int exchangedValue = counter.exchange(20); // oldValue 现在是 10, counter 现在是 20

int expected = 20;
int desired = 30;
while (!counter.compare_exchange_weak(expected, desired)) {
    // compare_exchange_weak 可能失败，即使 counter 的值等于 expected
    // 在循环中重试，更新 expected 的值
}
// counter 现在是 30 (如果 compare_exchange_weak 成功)
```
内存顺序: 原子操作可以指定内存顺序，控制不同线程之间内存访问的可见性。常用的内存顺序包括：
- ```
std::memory_order_relaxed
```
  : 最宽松的内存顺序，只保证原子性，不保证线程之间的同步。
- ```
std::memory_order_acquire
```
  : 当线程读取原子变量时，确保该线程能看到其他线程在之前写入原子变量的所有操作。
- ```
std::memory_order_release
```
  : 当线程写入原子变量时，确保该线程之前的所有操作对其他线程可见。
- ```
std::memory_order_acq_rel
```
  : 同时具有
```
acquire
```
  和
```
release
```
  语义。用于读-修改-写操作。
- ```
std::memory_order_seq_cst
```
  : 最强的内存顺序，提供顺序一致性，保证所有线程以相同的顺序看到所有原子操作。这是默认的内存顺序，但性能通常最差。
```
std::atomic<int> data(0);
std::atomic<bool> ready(false);

// 线程 1
void producer() {
    data.store(42, std::memory_order_relaxed);
    ready.store(true, std::memory_order_release);
}

// 线程 2
void consumer() {
    while (!ready.load(std::memory_order_acquire)) {
        // 等待 ready 变为 true
    }
    int value = data.load(std::memory_order_relaxed);
    // 使用 value
}
```

副标题1：原子变量有哪些常见的陷阱和误用？

原子变量的使用并非万无一失，存在一些常见的陷阱，尤其是在处理复杂的并发逻辑时。

ABA问题: 如果一个原子变量的值从A变为B，然后又变回A，那么
```
compare_exchange
```
操作可能会成功，即使实际上变量的值已经发生了变化。解决ABA问题可以使用版本号或者指针来跟踪变量的变化。例如，使用
```
std::atomic<std::pair<T, int>>
```
，其中
```
int
```
是版本号。
伪共享: 如果多个线程访问位于同一缓存行的不同原子变量，即使这些变量本身是原子操作的，也会导致性能下降。这是因为缓存行需要在不同的核心之间来回传递。可以使用填充 (padding) 来确保每个原子变量都位于不同的缓存行中。
```
alignas(64)
```
可以用来对齐变量到缓存行大小。
过度使用原子操作: 原子操作通常比非原子操作慢。过度使用原子操作可能会降低性能。只在必要的时候使用原子操作，并尽可能使用更宽松的内存顺序。
死锁: 虽然原子操作本身不会导致死锁，但在复杂的并发逻辑中，如果原子操作与其他同步机制（例如互斥锁）混合使用，仍然可能发生死锁。
忽略内存顺序: 错误地选择内存顺序可能会导致数据竞争和未定义的行为。仔细考虑不同线程之间的数据依赖关系，并选择合适的内存顺序。通常，
```
std::memory_order_seq_cst
```
是最安全的，但也是性能最差的。

阿里云AI平台
阿里云AI平台

下载

副标题2：如何选择合适的内存顺序？

选择合适的内存顺序需要仔细考虑不同线程之间的数据依赖关系。以下是一些选择内存顺序的指导原则：

没有数据依赖关系: 如果多个线程之间没有数据依赖关系，可以使用
```
std::memory_order_relaxed
```
。例如，多个线程同时增加一个计数器，而不需要保证线程之间的同步。
生产者-消费者模式: 在生产者-消费者模式中，生产者线程写入数据，消费者线程读取数据。生产者线程应该使用
```
std::memory_order_release
```
来发布数据，消费者线程应该使用
```
std::memory_order_acquire
```
来获取数据。
读-修改-写操作: 对于读-修改-写操作，应该使用
```
std::memory_order_acq_rel
```
。例如，原子地增加一个计数器，并返回旧的值。
顺序一致性: 如果需要保证所有线程以相同的顺序看到所有原子操作，可以使用
```
std::memory_order_seq_cst
```
。但是，这通常会降低性能。