当前位置：首页 > news >正文

【DeepSeek 学C++】std::atomic 用于线程控制，和内存强顺序一致性

news 来源：原创 2025/9/20 13:51:44

`std::atomic<bool> workerTerminate_{};`

std::atomic<bool> workerTerminate_{}; 是一个原子布尔变量的声明，变量名为 workerTerminate_。这种变量通常用于多线程编程中，用来控制或通知工作线程的终止。使用 std::atomic 可以确保对该变量的访问是线程安全的，即多个线程对 workerTerminate_ 的操作不会发生数据竞争，并且能够正确同步。

关键点

原子性：
- std::atomic<bool> 保证对 workerTerminate_ 的操作是原子的。这意味着不会有两个线程同时修改或读取 workerTerminate_，从而避免了竞争条件。
线程安全：
- 由于 workerTerminate_ 是原子的，多个线程可以安全地检查或修改它的值，而不需要额外的同步机制（如互斥锁）。
典型用途：
- 这种变量通常用作一个标志，用来通知工作线程停止执行。例如：
```
std::atomic<bool> workerTerminate_{false};void workerThread() {while (!workerTerminate_.load()) {// 执行任务}
}void stopWorker() {workerTerminate_.store(true);
}
```
- 在这个例子中，workerThread 会一直运行，直到另一个线程调用 stopWorker 将 workerTerminate_ 设置为 true。
内存顺序：
- 默认情况下，std::atomic 的操作使用顺序一致性（最强的内存顺序）。但你也可以根据需要指定其他内存顺序（如 std::memory_order_relaxed），以在某些场景下优化性能。

示例代码

#include <atomic>
#include <thread>
#include <iostream>std::atomic<bool> workerTerminate_{false};void workerThread() {while (!workerTerminate_.load()) {std::cout << "工作中..." << std::endl;std::this_thread::sleep_for(std::chrono::seconds(1));}std::cout << "工作线程已终止。" << std::endl;
}int main() {std::thread worker(workerThread);// 让工作线程运行一段时间std::this_thread::sleep_for(std::chrono::seconds(5));// 通知工作线程终止workerTerminate_.store(true);// 等待工作线程结束worker.join();return 0;
}

代码解释

workerThread 函数在一个循环中运行，每隔 1 秒打印一次 “工作中…”，直到 workerTerminate_ 被设置为
true。
main 函数创建了工作线程，让它运行 5 秒，然后通过将 workerTerminate_ 设置为 true 来通知线程终止。
工作线程在每次循环中检查 workerTerminate_ 的值，当发现其为 true 时退出循环并结束线程。

总结

`std::atomic<bool>` 是一种非常常用的多线程编程工具，特别适合用来实现线程间的简单通信（如终止信号）。它的原子性和线程安全性使得开发者无需额外使用锁或其他同步机制，从而简化了代码并提高了性能。

`std::atomic<bool>` 的操作使用顺序一致性（最强的内存顺序）

std::atomic<bool> 的操作默认使用**顺序一致性（Sequential Consistency，简称 SC）**的内存顺序。这是最严格的内存顺序模型，它保证了多线程程序的行为符合一种直观的、全局一致的顺序。

什么是顺序一致性？

顺序一致性可以理解为：

所有线程看到的操作顺序是一致的：即所有线程对内存的操作（读/写）看起来是按照某种全局顺序执行的。
每个线程的内部操作顺序保持不变: 即每个线程内部的代码执行顺序不会被重排。

换句话说，顺序一致性保证了多线程程序的行为就像所有线程的操作被串行化（一个接一个地执行）一样，且每个线程的操作顺序与代码中的顺序一致。

为什么顺序一致性是最强的内存顺序？

顺序一致性提供了最强的保证，因为它：

避免了指令重排（编译器或 CPU 不会对操作进行优化重排）
确保了所有线程对内存的修改是全局可见的，且顺序一致。

这种严格的保证使得程序的行为更容易理解和推理，但可能会牺牲一些性能。

举例说明

假设有两个线程，线程 A 和线程 B，它们分别修改和读取两个原子变量 x 和 y：

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> x{0};
std::atomic<int> y{0};
int r1, r2;void threadA() {x.store(1);  // 操作 1r1 = y.load();  // 操作 2
}void threadB() {y.store(1);  // 操作 3r2 = x.load();  // 操作 4
}int main() {std::thread t1(threadA);std::thread t2(threadB);t1.join();t2.join();std::cout << "r1 = " << r1 << ", r2 = " << r2 << std::endl;return 0;
}

顺序一致性的行为

在顺序一致性模型下，所有线程看到的操作顺序是一致的。可能的执行顺序包括：

线程 A 先执行，线程 B 后执行：
- 操作 1：x = 1
- 操作 2：r1 = y（此时 y 仍然是 0，所以 r1 = 0）
- 操作 3：y = 1
- 操作 4：r2 = x（此时 x 已经是 1，所以 r2 = 1）
- 结果：r1 = 0, r2 = 1
线程 B 先执行，线程 A 后执行：
- 操作 3：y = 1
- 操作 4：r2 = x（此时 x 仍然是 0，所以 r2 = 0）
- 操作 1：x = 1
- 操作 2：r1 = y（此时 y 已经是 1，所以 r1 = 1）
- 结果：r1 = 1, r2 = 0
操作交错执行
- 操作 1：x = 1
- 操作 3：y = 1
- 操作 2：r1 = y（此时 y 已经是 1，所以 r1 = 1）
- 操作 4：r2 = x（此时 x 已经是 1，所以 r2 = 1）
- 结果：r1 = 1, r2 = 1

在顺序一致性模型下，不可能出现 r1 = 0, r2 = 0 的情况，因为所有线程看到的操作顺序是一致的。

如果使用更弱的内存顺序会怎样？

如果使用更弱的内存顺序（如 std::memory_order_relaxed），编译器和 CPU 可能会对操作进行重排，导致一些违反直觉的结果。例如：

线程 A 的操作 2（r1 = y）可能会在操作 1（x = 1）之前执行。
线程 B 的操作 4（r2 = x）可能会在操作 3（y = 1）之前执行。

这样可能会导致 r1 = 0, r2 = 0 的结果，因为两个线程都读取到了未更新的值。

总结

顺序一致性是最强的内存顺序模型，保证了多线程程序的行为符合一种全局一致的顺序。

它避免了指令重排，并确保所有线程对内存的修改是全局可见的。

顺序一致性虽然易于理解和推理，但可能会牺牲一些性能。

在需要更高性能的场景中，可以使用更弱的内存顺序（如 std::memory_order_relaxed），但需要更谨慎地处理同步问题。

使用 std::memory_order_relaxed 的代码示例

std::memory_order_relaxed 是最弱的内存顺序模型，它只保证原子操作的原子性，但不提供任何同步或顺序保证。这意味着编译器和 CPU 可以自由地对操作进行重排，只要保证原子操作本身的原子性即可。

使用 std::memory_order_relaxed 可以提高性能，但需要开发者非常小心，因为程序的执行顺序可能会变得难以预测。

#include <atomic>
#include <thread>
#include <iostream>std::atomic<int> x{0};
std::atomic<int> y{0};
int r1, r2;void threadA() {x.store(1, std::memory_order_relaxed);  // 操作 1r1 = y.load(std::memory_order_relaxed); // 操作 2
}void threadB() {y.store(1, std::memory_order_relaxed);  // 操作 3r2 = x.load(std::memory_order_relaxed); // 操作 4
}int main() {std::thread t1(threadA);std::thread t2(threadB);t1.join();t2.join();std::cout << "r1 = " << r1 << ", r2 = " << r2 << std::endl;return 0;
}

可能的结果

由于使用了 std::memory_order_relaxed，编译器和 CPU 可能会对操作进行重排。因此，以下结果都是可能的：

r1 = 0, r2 = 1
r1 = 1, r2 = 0
r1 = 1, r2 = 1
r1 = 0, r2 = 0（这是顺序一致性模型下不可能出现的结果）

为什么会出现 r1 = 0, r2 = 0？

在 std::memory_order_relaxed 下，编译器和 CPU 可能会对操作进行重排。例如：

线程 A 的操作 2（r1 = y）可能会在操作 1（x = 1）之前执行。
线程 B 的操作 4（r2 = x）可能会在操作 3（y = 1）之前执行。

这样，两个线程都读取到了未更新的值，导致 r1 = 0, r2 = 0。

更复杂的例子：使用 std::memory_order_relaxed 实现简单的计数器

以下是一个使用 std::memory_order_relaxed 实现计数器的例子：

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

代码解释

counter.fetch_add(1, std::memory_order_relaxed)：

使用 std::memory_order_relaxed 对计数器进行原子加 1 操作。由于是 relaxed
模式，其他线程可能不会立即看到计数器的更新。

2 .多线程累加：

10 个线程并发执行，每个线程对计数器累加 10000 次。
最终计数器的值应该是 10 * 10000 = 100000。

结果：

由于 std::memory_order_relaxed 只保证原子性，不保证顺序，因此其他线程可能会看到计数器的中间状态。
但最终结果仍然是正确的，因为 fetch_add 是原子的。

std::atomic<bool> workerTerminate_{};

关键点

示例代码

代码解释

总结

std::atomic<bool> 是一种非常常用的多线程编程工具，特别适合用来实现线程间的简单通信（如终止信号）。它的原子性和线程安全性使得开发者无需额外使用锁或其他同步机制，从而简化了代码并提高了性能。

std::atomic<bool> 的操作使用顺序一致性（最强的内存顺序）

什么是顺序一致性？

为什么顺序一致性是最强的内存顺序？

举例说明

顺序一致性的行为

如果使用更弱的内存顺序会怎样？

总结

使用 std::memory_order_relaxed 的代码示例

可能的结果

为什么会出现 r1 = 0, r2 = 0？

更复杂的例子：使用 std::memory_order_relaxed 实现简单的计数器

代码解释

相关文章：

`std::atomic<bool> workerTerminate_{};`

`std::atomic<bool>` 是一种非常常用的多线程编程工具，特别适合用来实现线程间的简单通信（如终止信号）。它的原子性和线程安全性使得开发者无需额外使用锁或其他同步机制，从而简化了代码并提高了性能。

`std::atomic<bool>` 的操作使用顺序一致性（最强的内存顺序）