好的，我们今天来聊聊 C++ 原子操作中的两位重量级选手：compare_exchange_weak 和 compare_exchange_strong。这两个家伙看着名字挺像，功能也差不多，都是用来实现原子比较和交换的，但是它们的“脾气”却大不相同。掌握它们的区别，能让你在并发编程的道路上少踩不少坑。
故事的开始：原子操作的重要性
在多线程的世界里，多个线程可能会同时访问和修改共享的数据。如果没有适当的同步机制，就会出现数据竞争，导致程序行为不可预测，轻则程序崩溃，重则数据损坏。原子操作就是解决这个问题的利器。
原子操作保证了操作的不可分割性。也就是说，从一个线程的角度来看，原子操作要么完全执行，要么完全不执行，不会出现中间状态。这就像你银行转账，要么转账成功，要么转账失败，不可能出现钱从你的账户扣了，但没到对方账户的情况。
C++ 的 <atomic> 头文件提供了一系列原子类型和原子操作，让我们能方便地进行并发编程。compare_exchange_weak 和 compare_exchange_strong 就是其中的两个重要成员。
compare_exchange_weak 和 compare_exchange_strong 的基本用法
这两个函数的原型大致如下（简化版）：
bool compare_exchange_weak(T& expected, T desired, std::memory_order success, std::memory_order failure) noexcept;
bool compare_exchange_strong(T& expected, T desired, std::memory_order success, std::memory_order failure) noexcept;
bool compare_exchange_weak(T& expected, T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;
bool compare_exchange_strong(T& expected, T desired, std::memory_order order = std::memory_order_seq_cst) noexcept;参数解释：
expected: 一个引用，指向期望的值。如果原子变量的当前值等于expected，则原子变量会被替换为desired。注意，这个expected的值会被更新为原子变量的实际值，无论交换是否成功。 这点非常重要！desired: 希望写入原子变量的新值。success: 如果交换成功，使用的内存顺序。failure: 如果交换失败，使用的内存顺序。order: 如果成功和失败使用相同的内存顺序。默认为std::memory_order_seq_cst。
返回值：
true: 如果交换成功。false: 如果交换失败 (原子变量的当前值不等于expected)。
简单来说，这两个函数的工作流程都是：
- 读取原子变量的当前值。
- 将当前值与
expected进行比较。 - 如果相等，则将原子变量的值替换为
desired。 - 返回
true(表示交换成功)。 - 如果不相等，则将
expected的值更新为原子变量的当前值。 - 返回
false(表示交换失败)。
代码示例：一个简单的计数器
假设我们要实现一个线程安全的计数器：
#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
std::atomic<int> counter(0);
void increment_counter() {
int expected = counter.load();
int desired = expected + 1;
while (!counter.compare_exchange_weak(expected, desired)) {
desired = expected + 1; // 基于新的 expected 值重新计算 desired
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 10; ++i) {
threads.emplace_back(increment_counter);
}
for (auto& thread : threads) {
thread.join();
}
std::cout << "Counter value: " << counter << std::endl;
return 0;
}在这个例子中，我们使用 compare_exchange_weak 来原子地递增计数器。while 循环保证了即使 compare_exchange_weak 偶尔失败，我们也能最终成功地递增计数器。
weak 和 strong 的关键区别：伪失败 (Spurious Failure)
现在，我们要揭开 compare_exchange_weak 和 compare_exchange_strong 最核心的区别：伪失败 (Spurious Failure)。
compare_exchange_strong 保证，只有当原子变量的当前值确实与 expected 不相等时，才会返回 false。也就是说，如果当前值与 expected 相等，compare_exchange_strong 保证交换一定会成功。
而 compare_exchange_weak 则允许出现伪失败。即使原子变量的当前值与 expected 相等，compare_exchange_weak 也可能返回 false。 这听起来有点奇怪，但这是允许的。
为什么会有伪失败？
伪失败的出现与底层硬件的实现有关。在某些架构上，原子操作的实现可能会受到一些干扰，例如：
- Cache Coherence: CPU缓存一致性协议可能导致短暂的冲突，使得原子操作看起来好像失败了。
- 指令流水线: CPU指令流水线中的一些优化可能会导致原子操作提前完成比较，但由于其他操作的干扰，最终导致交换失败。
- 中断: 在原子操作执行过程中，如果发生中断，也可能导致操作失败。
简单来说，伪失败并不是因为原子变量的值真的变了，而是因为一些硬件上的原因，导致原子操作未能成功完成。
weak 和 strong 的适用场景
既然 compare_exchange_weak 可能会出现伪失败，那它有什么用呢？为什么不直接用 compare_exchange_strong 呢？
答案是：性能。
在某些情况下，compare_exchange_weak 的性能可能比 compare_exchange_strong 更好。因为 compare_exchange_weak 允许硬件进行一些优化，而 compare_exchange_strong 则必须保证在值相等的情况下交换一定成功，这可能会限制硬件的优化空间。
所以，weak 和 strong 的选择取决于你的具体需求：
-
如果你需要绝对的可靠性，确保在值相等的情况下交换一定成功，那么使用
compare_exchange_strong。 例如，在实现锁的时候，通常需要使用compare_exchange_strong来保证锁的互斥性。 -
如果你对性能有更高的要求，并且能够容忍偶尔的伪失败，那么可以使用
compare_exchange_weak。 但是，在使用compare_exchange_weak时，你需要在一个循环中重试操作，直到成功为止。就像我们之前的计数器示例一样。
总结：一张表格胜过千言万语
| 特性 | compare_exchange_strong |
compare_exchange_weak |
|---|---|---|
| 可靠性 | 高，保证交换成功 | 较低，可能出现伪失败 |
| 性能 | 可能略差 | 可能略好 |
| 适用场景 | 需要绝对可靠性的场景 | 对性能敏感，可容忍伪失败的场景 |
| 是否需要循环重试 | 不需要 | 需要 |
代码示例：使用 compare_exchange_strong 实现自旋锁
#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
class SpinLock {
private:
std::atomic_flag locked = ATOMIC_FLAG_INIT;
public:
void lock() {
while (locked.test_and_set(std::memory_order_acquire)) {
// 自旋等待锁释放
}
}
void unlock() {
locked.clear(std::memory_order_release);
}
};
SpinLock lock;
std::atomic<int> shared_data(0);
void increment_shared_data() {
for (int i = 0; i < 100000; ++i) {
lock.lock();
shared_data++;
lock.unlock();
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 4; ++i) {
threads.emplace_back(increment_shared_data);
}
for (auto& thread : threads) {
thread.join();
}
std::cout << "Shared data value: " << shared_data << std::endl;
return 0;
}在这个例子中，我们使用了 std::atomic_flag 和 test_and_set (类似于 compare_exchange_strong 的效果) 来实现一个简单的自旋锁。自旋锁需要保证在尝试获取锁的时候，如果锁已经被其他线程占用，则当前线程会一直自旋等待，直到锁被释放。因此，我们需要使用 compare_exchange_strong 或类似的机制来保证锁的互斥性。
内存顺序 (Memory Order) 的选择
compare_exchange_weak 和 compare_exchange_strong 的另一个重要方面是内存顺序。内存顺序指定了原子操作与其他内存访问之间的顺序关系。选择合适的内存顺序对于保证程序的正确性和性能至关重要。
常见的内存顺序包括：
std::memory_order_relaxed: 最宽松的内存顺序。只保证原子性，不保证任何顺序。std::memory_order_acquire: 获取顺序。当一个线程成功地读取一个原子变量时，所有在写入该原子变量的线程在释放顺序之前发生的写入，都对当前线程可见。通常用于锁的获取。std::memory_order_release: 释放顺序。当一个线程写入一个原子变量时，所有在该线程释放顺序之后发生的写入，都对其他线程可见。通常用于锁的释放。std::memory_order_acq_rel: 获取-释放顺序。同时具有获取和释放的特性。std::memory_order_seq_cst: 顺序一致性。最强的内存顺序。保证所有线程看到的原子操作的顺序都是一致的。也是默认的内存顺序。
在选择内存顺序时，需要根据具体的需求进行权衡。一般来说，越强的内存顺序，性能越差。但如果内存顺序选择不当，可能会导致数据竞争和程序错误。
在我们的计数器示例中，我们使用了默认的 std::memory_order_seq_cst。在自旋锁示例中，我们使用了 std::memory_order_acquire 和 std::memory_order_release 来保证锁的互斥性。
总结：选择的艺术
compare_exchange_weak 和 compare_exchange_strong 都是强大的工具，但它们的使用需要谨慎。你需要根据你的具体需求，权衡可靠性和性能，选择合适的函数和内存顺序。
记住，compare_exchange_weak 可能会出现伪失败，所以你需要在一个循环中重试操作。而 compare_exchange_strong 则保证在值相等的情况下交换一定成功。
选择正确的工具，能让你在并发编程的道路上走得更远，写出更高效、更可靠的程序。希望今天的讲解能帮助你更好地理解 compare_exchange_weak 和 compare_exchange_strong，并在你的项目中灵活运用它们。
最后一点提示
在实际开发中，尽量避免过度使用原子操作。原子操作虽然能保证线程安全，但也会带来一定的性能开销。只有在必要的时候才使用原子操作，并尽量选择合适的内存顺序，以获得最佳的性能。
并发编程是一门复杂的艺术，需要不断学习和实践。希望大家能够通过今天的讲解，对原子操作有更深入的理解，并在实际项目中灵活运用它们，写出高质量的并发程序。