C++并发编程之内存顺序一致性
std::memory_order_seq_cst 是 C++11 引入的内存模型中的一种内存顺序（memory order），全称为 Sequential Consistency（顺序一致性）。它是 C++ 中最严格的内存顺序，提供了最强的同步保证。下面详细解释其含义、意图、作用以及适用场合，并通过示例来说明。
1. std::memory_order_seq_cst 的含义
std::memory_order_seq_cst 表示 顺序一致性，这意味着：
- 全局顺序一致性：所有线程看到的操作顺序是一致的。换句话说，所有使用
std::memory_order_seq_cst的原子操作（包括load、store、read-modify-write）在所有线程中表现出相同的执行顺序。 - 先发生关系（happens-before）：在同一线程中，操作之间的
happens-before关系是显式的，而在不同线程之间，操作的顺序也是一致的。
简单来说，std::memory_order_seq_cst 保证程序的执行顺序与代码的顺序一致，且在所有线程中观察到的顺序是相同的。
2. 意图和作用
std::memory_order_seq_cst 的主要作用是：
- 简化多线程编程模型：它提供了类似单线程的执行顺序，使得开发者可以更容易地理解和推理多线程程序的行为。
- 强制全局顺序：确保所有线程都能看到相同的全局内存操作顺序，从而避免复杂的同步问题。
- 原子操作的强一致性：在原子操作中使用
std::memory_order_seq_cst时，所有线程都会看到一致的内存状态。
3. 适用场合
std::memory_order_seq_cst 适用于以下场景：
- 需要强一致性：当你需要确保所有线程都看到相同的全局内存操作顺序时，使用
std::memory_order_seq_cst。例如，在需要严格同步的场景中（如计数器、屏障或临界区）。 - 简化推理：在多线程同步逻辑比较简单且不需要考虑性能优化的场景中，使用
std::memory_order_seq_cst可以简化程序的推理和调试。 - 临界区保护：在需要确保临界区操作的顺序一致性时，使用
std::memory_order_seq_cst。
4. 示例说明
示例 1：简单的计数器
假设我们有一个共享的计数器，多个线程会并发地对其进行自增操作。我们希望确保所有线程都能看到一致的全局顺序。
#include <atomic>
#include <iostream>
#include <thread>
std::atomic<int> counter{0};
void increment() {
for (int i = 0; i < 1000; ++i) {
counter.fetch_add(1, std::memory_order_seq_cst); // 使用顺序一致性
}
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter.load(std::memory_order_seq_cst) << std::endl;
return 0;
}
说明：
counter.fetch_add(1, std::memory_order_seq_cst)使用std::memory_order_seq_cst，确保所有线程看到的计数器自增顺序是一致的。- 最终的
counter.load(std::memory_order_seq_cst)也使用std::memory_order_seq_cst，确保所有线程都能看到一致的最终结果。
示例 2：双检查锁（不推荐）
虽然 std::memory_order_seq_cst 可以用于双检查锁模式的实现，但由于其开销较大，通常不推荐在这种场景中使用。不过，我们可以用它来展示效果。
#include <atomic>
#include <mutex>
#include <iostream>
class Singleton {
public:
static Singleton* instance() {
auto* tmp = instance_.load(std::memory_order_seq_cst);
if (tmp == nullptr) {
std::lock_guard<std::mutex> lock(mutex_);
tmp = instance_.load(std::memory_order_seq_cst);
if (tmp == nullptr) {
tmp = new Singleton();
instance_.store(tmp, std::memory_order_seq_cst);
}
}
return tmp;
}
private:
Singleton() = default;
~Singleton() = default;
static std::atomic<Singleton*> instance_;
static std::mutex mutex_;
};
std::atomic<Singleton*> Singleton::instance_{nullptr};
std::mutex Singleton::mutex_;
int main() {
Singleton* s = Singleton::instance();
std::cout << "Singleton instance created." << std::endl;
return 0;
}
说明：
- 在双检查锁模式中，我们使用
std::memory_order_seq_cst来确保所有线程看到的instance_状态是一致的。 - 需要注意的是，这种实现虽然正确，但由于
std::memory_order_seq_cst的开销较大，通常会使用更轻量级的内存顺序（如std::memory_order_acquire和std::memory_order_release）来优化性能。
示例 3：屏障同步
假设我们有两个线程，一个线程负责设置标志位，另一个线程负责检查标志位。我们希望确保设置标志位的线程在检查线程之前完成操作。
#include <atomic>
#include <iostream>
#include <thread>
std::atomic<bool> ready{false};
int data = 0;
void writer() {
data = 100; // 写入数据
ready.store(true, std::memory_order_seq_cst); // 设置标志位
}
void reader() {
while (!ready.load(std::memory_order_seq_cst)) { // 等待标志位
std::this_thread::yield();
}
std::cout << "Data: " << data << std::endl; // 读取数据
}
int main() {
std::thread t1(writer);
std::thread t2(reader);
t1.join();
t2.join();
return 0;
}
说明：
ready.store(true, std::memory_order_seq_cst)和ready.load(std::memory_order_seq_cst)确保所有线程都能看到一致的ready状态。- 这样可以保证
writer线程在reader线程之前完成操作。
5. 总结
std::memory_order_seq_cst提供了最强的内存同步保证，适合需要全局一致性和顺序一致性的场景。- 在性能敏感的场景中，建议选择更轻量级的内存顺序（如
std::memory_order_acquire和std::memory_order_release）以优化性能。 - 示例展示了
std::memory_order_seq_cst在计数器、双检查锁和屏障同步中的应用。
std::memory_order_seq_cst 是 C++11 引入的内存模型中的一种内存顺序，代表了顺序一致性（Sequential Consistency）。在不同操作系统和 CPU 架构下，其实现方法可能有所不同，但它们都必须满足 C++ 标准对顺序一致性的要求。
1. Windows 操作系统
在 Windows 操作系统上，std::memory_order_seq_cst 的实现依赖于底层的 CPU 指令和内存模型。Windows 提供了多线程编程的支持，包括原子操作和内存屏障。
-
原子操作：Windows 提供了
Interlocked*函数来实现原子操作，例如InterlockedExchange和InterlockedCompareExchange。这些函数在内部使用了 CPU 的锁前缀指令（如lock前缀）来保证原子性。 -
内存屏障：Windows 提供了
MemoryBarrier和WriteBarrier等函数来实现内存屏障，确保内存操作的顺序。
对于 std::memory_order_seq_cst，编译器会生成适当的原子操作和内存屏障指令，以确保顺序一致性。具体来说，在 x64 架构上，这通常涉及到使用 lock 前缀的指令和 mfence 指令来实现全内存屏障。
2. Linux 操作系统
在 Linux 操作系统上，std::memory_order_seq_cst 的实现同样依赖于底层的 CPU 指令和内存模型。Linux 提供了 POSIX 线程（pthreads）和原子操作的支持。
-
原子操作：Linux 提供了
atomic_*操作，例如atomic_load和atomic_store，这些操作在内部使用了 CPU 的原子指令。 -
内存屏障：Linux 提供了
memory_barrier和read_barrier_depends等内存屏障函数，确保内存操作的顺序。
在 x64 架构上，编译器会生成 lock 前缀的指令来保证原子性，并使用 mfence 指令来实现全内存屏障，以满足 std::memory_order_seq_cst 的要求。
3. macOS 操作系统
在 macOS 操作系统上，std::memory_order_seq_cst 的实现也依赖于底层的 CPU 指令和内存模型。macOS 提供了 Grand Central Dispatch (GCD) 和原子操作的支持。
-
原子操作：macOS 提供了
OSAtomic*函数来实现原子操作，例如OSAtomicCompareAndSwapInt。 -
内存屏障：macOS 提供了
OpaqueMemoryBarrier和LoadCommand等内存屏障函数。
在 x64 架构上，编译器会生成相应的原子指令和内存屏障指令，以确保 std::memory_order_seq_cst 的顺序一致性。
4. X64 CPU 的支持
x64 架构的 CPU 提供了对多线程编程和内存模型的支持，包括原子操作和内存屏障指令。
-
原子操作：x64 CPU 支持带
lock前缀的指令，这些指令在总线上进行锁定，确保操作的原子性。例如，lock inc dword ptr [rsp]会原子地增加内存地址rsp处的值。 -
内存屏障：x64 CPU 提供了多种内存屏障指令，如
mfence、lfence和sfence，分别用于全内存屏障、负载屏障和存储屏障。这些指令用于控制内存操作的顺序，确保某些操作在屏障之前或之后完成。
对于 std::memory_order_seq_cst，编译器会生成 lock 前缀的原子指令，并在需要时插入 mfence 指令来确保顺序一致性。
5. 总结
在 Windows、Linux 和 macOS 等操作系统上，std::memory_order_seq_cst 的实现都依赖于底层 CPU 的原子指令和内存屏障指令。编译器会根据目标架构生成相应的机器码，以确保满足 C++ 标准对顺序一致性的要求。在 x64 架构上，这通常涉及到使用 lock 前缀的指令和 mfence 指令来实现原子操作和内存屏障。