文章目录

- 一、什么是原子操作？
- 二、为什么需要原子操作？
- 三、C++11中的<atomic>头文件
- 四、基本使用
- - 1. 声明原子变量
  - 2. 基本原子操作
- 五、内存顺序（Memory Order）
- - 示例：使用内存顺序实现自旋锁
- 六、原子类型模板
- 七、实际应用示例
- - 1. 线程安全的计数器
  - 2. 双重检查锁定（Double-Checked Locking）
- 八、性能考虑
- 九、常见陷阱
- 十、总结

一、什么是原子操作？

原子操作（Atomic Operations）是指不可被中断的一个或一系列操作。在多线程编程中，原子操作就像是"不可分割的最小单位"，要么完全执行，要么完全不执行，不会出现执行到一半被其他线程打断的情况。

二、为什么需要原子操作？

考虑以下场景：

int counter = 0;// 线程1
void increment() {counter++;
}// 线程2
void decrement() {counter--;
}

在多线程环境下，counter++ 和 counter-- 这样的操作实际上包含多个步骤（读取、修改、写入），可能导致竞态条件（Race Condition）。原子操作可以确保这些操作不可分割地完成。

三、C++11中的头文件

C++11引入了<atomic>头文件，提供了一系列原子类型和操作。主要包含：

基本原子类型（atomic_int, atomic_bool等）
类模板std::atomic<T>
原子操作函数
内存顺序控制

四、基本使用

1. 声明原子变量

#include <atomic>
#include <iostream>int main() {std::atomic<int> counter(0);  // 初始化为0counter.store(10);  // 原子存储int value = counter.load();  // 原子读取std::cout << "Counter: " << value << std::endl;return 0;
}

2. 基本原子操作

std::atomic<int> num(0);// 原子加法
num.fetch_add(5);  // 相当于 num += 5// 原子减法
num.fetch_sub(3);  // 相当于 num -= 3// 原子交换
int old = num.exchange(10);  // 将num设为10，返回旧值// 比较交换（CAS操作）
int expected = 10;
bool success = num.compare_exchange_strong(expected, 15);
// 如果num == expected，则设为15，返回true
// 否则将expected设为num的实际值，返回false

五、内存顺序（Memory Order）

内存顺序指定了原子操作周围的内存访问如何排序，是原子操作的高级特性。C++11定义了6种内存顺序：

memory_order_relaxed：最宽松的顺序，只保证原子性
memory_order_consume：依赖于此原子变量的后续操作不能重排序到它前面
memory_order_acquire：后续操作不能重排序到它前面
memory_order_release：前面操作不能重排序到它后面
memory_order_acq_rel：acquire + release
memory_order_seq_cst：最严格的顺序（默认）

示例：使用内存顺序实现自旋锁

#include <atomic>
#include <thread>class SpinLock {std::atomic_flag flag = ATOMIC_FLAG_INIT;public:void lock() {while (flag.test_and_set(std::memory_order_acquire)) {// 自旋等待}}void unlock() {flag.clear(std::memory_order_release);}
};

六、原子类型模板

std::atomic可以用于任何可平凡复制的类型：

struct Point {int x, y;
};std::atomic<Point> atomic_point;void updatePoint() {Point new_point{10, 20};atomic_point.store(new_point, std::memory_order_release);
}void readPoint() {Point current = atomic_point.load(std::memory_order_acquire);std::cout << "Point: (" << current.x << ", " << current.y << ")\n";
}

七、实际应用示例

1. 线程安全的计数器

#include <atomic>
#include <thread>
#include <vector>
#include <iostream>std::atomic<int> counter(0);
const int kIncrementsPerThread = 100000;
const int kThreadCount = 10;void increment() {for (int i = 0; i < kIncrementsPerThread; ++i) {counter.fetch_add(1, std::memory_order_relaxed);}
}int main() {std::vector<std::thread> threads;for (int i = 0; i < kThreadCount; ++i) {threads.emplace_back(increment);}for (auto& t : threads) {t.join();}std::cout << "Final counter value: " << counter << std::endl;return 0;
}

2. 双重检查锁定（Double-Checked Locking）

class Singleton {
private:static std::atomic<Singleton*> instance;static std::mutex mutex;Singleton() {}public:static Singleton* getInstance() {Singleton* tmp = instance.load(std::memory_order_acquire);if (tmp == nullptr) {std::lock_guard<std::mutex> lock(mutex);tmp = instance.load(std::memory_order_relaxed);if (tmp == nullptr) {tmp = new Singleton();instance.store(tmp, std::memory_order_release);}}return tmp;}
};std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;