C++笔记---并发支持库（atomic）

1. atomic

C++11 引入的<atomic>头文件和std::atomic模板是无锁并发编程的核心，用于实现多线程间的原子操作，避免数据竞争（data race），替代传统的互斥锁（如 std::mutex）以提升并发性能。

使用atomic的成员函数，对T类型的数据进行操作是原子的，这就使得某些简单的操作不再需要我们去加锁访问，而是直接采用原子操作。例如，一个多线程共享的计数器：

atomic<int> a_cnt = 0; int cnt = 0; void func() { for (int i = 0; i < 100000; i++) { ++a_cnt; ++cnt; } } int main() { vector<thread> pool; for (int i = 0; i < 4; i++) { pool.emplace_back(func); } for (auto& t : pool) { t.join(); } cout << "原子：" << a_cnt << endl; cout << "非原子：" << cnt << endl; return 0; }

值得注意的是，atomic作为模板，实际上并不完全支持所有类型。

主要支持的是整型家族、指针类型，以及任何满足 CopyConstructible 和 CopyAssignable 的可简单复制 (TriviallyCopyable)类型，例如：

struct Counters { int a; int b; }; // user-defined trivially-copyable type std::atomic<Counters> cnt; // specialization for the user-defined type

从C++20开始，atomic对智能指针进行了特化：

如果如下六个函数的返回值均为true，则说明类型 T可以使用原子操作，否则不行：

std::is_trivially_copyable<T>::value std::is_copy_constructible<T>::value std::is_move_constructible<T>::value std::is_copy_assignable<T>::value std::is_move_assignable<T>::value std::is_same<T, typename std::remove_cv<T>::type>::value

注意：std::atomic 对象不可拷贝、不可移动，因为拷贝 / 移动会破坏原子性。

1.1 核心成员函数

1.2 CAS操作

CAS 是无锁编程的基石，即Compare And Set或Compare And Swap，上面所有对值进行修改的成员函数，底层都是通过如下两个函数实现：

bool compare_exchange_weak( T& expected, T desired) bool compare_exchange_strong( T& expected, T desired)

这两个函数均为原子操作，依赖于硬件提供的CAS指令，核心原理为：

比较原子对象的当前值与expected：

• 若相等：将原子对象值设为desired，返回true；
• 若不等：将expected更新为原子对象的当前值，返回false。

weak 与 strong 的区别在于是否使用缓存一致性协议：

• weak：弱版本，可能 “伪失败”（值相等但返回 false），性能更高；
• strong：强版本，值相等时必成功，无伪失败。

例如，operator++的底层实现可能与Add函数的实现相似：

atomic<int> a_cnt = 0; int cnt = 0; void Add(atomic<int>& cnt) { int old = cnt.load(); // cnt与old的值相同，则将new赋值给cnt，否则将cnt的值更新给old // 确保将数据写回之前，没有其他线程对目标数据进行了修改，进而导致数据的覆盖 // 本质上来说，atomic的原理就是在将数据写回之前验证数据是否已被其他线程修改 // 若已被修改则重新计算更新后的值，并再次尝试写回，直到某次成功 // while (!atomic_compare_exchange_weak(&cnt, &old, old + 1)); while (!a_cnt.compare_exchange_weak(old, old + 1)); } void func() { for (int i = 0; i < 100000; i++) { Add(a_cnt); ++cnt; } } int main() { vector<thread> pool; for (int i = 0; i < 4; i++) { pool.emplace_back(func); } for (auto& t : pool) { t.join(); } cout << "原子：" << a_cnt << endl; cout << "非原子：" << cnt << endl; return 0; }

再例如，使用CAS操作实现无锁的链式栈（部分代码）：

#pragma once #include <atomic> template <typename T> class Node { int _val; Node* _next; Node(int val = 0, Node* next = nullptr) :_val(val) ,_next(next) { } }; template <typename T> class LockFreeStack { public: void push(const T& val) { Node<T>* newNode = new Node<T>(val, _head.load()); while (!_head.compare_exchange_weak(newNode->next, newNode)); } private: std::atomic<Node<T>*> _head = nullptr; };

1.3 内存序（Memory Order）

std::atomic 的所有操作都可指定内存序参数（默认 std::memory_order_seq_cst），用于控制：

• 指令重排序：编译器 / CPU 是否会重排原子操作的前后指令；
• 内存可见性：一个线程的写操作对另一个线程的读操作的可见性。

例如：

通常来说使用默认内存序即可，各内存序的效率差别实际上并不大，优先保证正确性。在要求极致性能的场景下，我们再考虑对内存序进行优化。

2. 原子操作实现自旋锁

#pragma once #include <atomic> class SpinLock1 { public: void lock() { // exchange: 将对象值设置为参数值，返回原本的值 while (_flag.exchange(true)) { // 自旋等待锁释放 } } void unlock() { _flag.store(false); } private: std::atomic<bool> _flag = false; }; class SpinLock2 { public: void lock() { while (_flag.test_and_set()) { // 自旋等待锁释放 } } void unlock() { _flag.clear(); } private: std::atomic_flag _flag = ATOMIC_FLAG_INIT; };

3. 无锁队列

未来补充。。。