C++如何在多线程中避免内存重排（重排.多线程.内存.如何在...）

wufei123 发布于 2025-09-17 阅读（14）
使用std::atomic和内存序（如memory_order_release/acquire）可有效防止C++多线程中的内存重排，确保共享数据的可见性和顺序性。

c++如何在多线程中避免内存重排

在C++多线程编程中，避免内存重排的核心策略是使用原子操作（

std::atomic
）和内存屏障/栅栏（
std::atomic_thread_fence
）。这些机制能够强制编译器和CPU遵循特定的内存访问顺序，从而确保不同线程间共享数据的可见性和一致性，有效防止因重排导致的竞态条件和数据不一致问题。 解决方案

要有效避免C++多线程中的内存重排，我们主要依赖

std::atomic
类型和其提供的内存序（
memory_order
）语义。
std::atomic
封装了对基本数据类型的原子操作，这些操作本身就包含了必要的内存屏障指令，以确保在不同线程间的可见性和顺序性。

具体来说，当对一个共享变量进行读写时，如果这个变量不是

std::atomic
类型，那么编译器和CPU可能会为了优化性能，改变这些操作的执行顺序，或者将写操作的结果延迟到其他线程可见。这在单线程环境下通常无害，但在多线程中就可能导致一个线程看到的内存状态与另一个线程实际执行的顺序不符。 

std::atomic
通过其内置的内存序参数，允许我们精细地控制原子操作的可见性保证。最常用的内存序包括： 
  • std::memory_order_relaxed
    : 最弱的内存序，只保证操作本身的原子性，不提供任何跨线程的顺序保证。它就像是说：“我只管我自己，不关心别人怎么看。”
  • std::memory_order_acquire
    : 读操作使用，确保该操作之后的所有内存访问不会被重排到该操作之前。它就像是说：“我拿到这个值之后，才能开始做其他事情。”
  • std::memory_order_release
    : 写操作使用，确保该操作之前的所有内存访问不会被重排到该操作之后。它就像是说：“我把所有事情都做完之后，才把这个值放出去。”
  • std::memory_order_acq_rel
    : 读-改-写操作使用，同时具备
    acquire
    和
    release
    的语义。
  • std::memory_order_seq_cst
    : 最强的内存序，提供全局的顺序一致性。所有使用
    seq_cst
    的操作都会在一个单一的全局总序中被执行，且对所有线程可见。虽然最安全，但性能开销也最大。

通常，我们会将

release
操作与
acquire
操作配对使用，以建立一个“同步点”，确保
release
操作之前的所有内存写入对
acquire
操作之后的所有内存读取都是可见的。

对于那些不能直接使用

std::atomic
封装的复杂数据结构，或者需要在非原子操作之间建立顺序关系的场景，我们可以使用
std::atomic_thread_fence
来显式插入内存屏障。它不关联任何数据，只是在程序流中插入一个屏障，强制屏障两侧的内存操作不能跨越屏障重排。
#include <atomic>
#include <thread>
#include <vector>
#include <iostream>

std::atomic<bool> ready_flag(false);
int data = 0;

void producer() {
    data = 42; // 非原子操作
    // 确保data的写入在ready_flag设置为true之前完成
    ready_flag.store(true, std::memory_order_release); 
    std::cout << "Producer set data and flag." << std::endl;
}

void consumer() {
    // 等待ready_flag变为true
    while (!ready_flag.load(std::memory_order_acquire)) {
        std::this_thread::yield(); // 避免忙等
    }
    // 确保在读取data之前，ready_flag的写入已经可见
    std::cout << "Consumer read data: " << data << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();

    return 0;
}

在这个例子中，

ready_flag.store(true, std::memory_order_release)
确保
data = 42
这个非原子操作的写入，在
ready_flag
被设置为
true
之前完成，并且对其他线程可见。而
ready_flag.load(std::memory_order_acquire)
则确保当它读取到
true
时，
data = 42
的写入也已经可见。如果没有这些内存序，
consumer
线程可能会在
data
还没被写入42之前就读取到它。 为什么CPU和编译器会进行内存重排？

内存重排并非一个“错误”，而是现代计算机系统为了追求极致性能而采取的一种优化手段。它发生在两个层面：

  1. 编译器重排（Compiler Reordering）：编译器在生成机器码时，可能会改变指令的执行顺序，只要这种改变不影响单线程程序的最终结果。比如，如果两个独立的内存操作之间没有数据依赖，编译器可能会交换它们的顺序，以便更好地利用CPU的流水线或减少缓存未命中。它就像一个高效的厨师，为了更快地准备好菜品，可能会先切菜再烧水，而不是严格按照食谱一步步来，只要最终的菜品味道不变。

  2. 处理器重排（Processor Reordering）：现代CPU拥有复杂的乱序执行（Out-of-Order Execution）引擎。它们不会严格按照程序指令的顺序执行，而是会动态地分析指令之间的依赖关系，并尽可能地并行执行独立的指令。此外，CPU的缓存系统也会引入写入缓冲（Write Buffer）和缓存一致性协议（Cache Coherence Protocol）等机制，这些都可能导致一个处理器核心的写入操作，不能立即被另一个核心观察到。举个例子，你给朋友发消息，消息先进入你的发送队列，而不是直接出现在朋友的手机上，这个过程就存在一个“延迟”和“重排”的可能。

这些优化在单线程环境中是完全透明且有益的，它们显著提升了程序的执行效率。但在多线程环境中，当多个线程共享数据时，如果没有适当的同步机制，这些重排就会打破我们对程序执行顺序的直观假设，导致数据不一致、竞态条件等难以调试的并发问题。因此，理解内存重排的本质，才能更好地选择合适的同步原语来“驯服”它。

std::atomic 如何保证内存可见性和顺序性？ 

std::atomic
通过在底层插入内存屏障（Memory Barriers）指令来保证内存的可见性和顺序性。这些屏障指令会强制CPU和编译器在特定点上停止重排操作，并确保之前的所有内存写入对其他处理器核心可见，同时刷新或失效相关缓存行。

让我们深入看看不同的

memory_order
是如何实现这一点的： 

  • std::memory_order_relaxed
    : Post AI Post AI

    博客文章AI生成器

    Post AI50 查看详情 Post AI
    • 保证: 仅保证操作本身的原子性。
    • 机制: 通常不插入任何内存屏障。它允许编译器和CPU对原子操作周围的内存访问进行任意重排，只要不破坏操作本身的原子性。这在某些计数器或统计场景中非常有用，比如一个线程只增加计数器，而不关心其他线程何时看到最新值。
    • 示例: 
      counter.fetch_add(1, std::memory_order_relaxed);

  • std::memory_order_acquire
    :
    • 保证: 一个
      acquire
      操作（通常是读操作）会“获取”内存，确保该操作之后的所有内存访问不会被重排到
      acquire
      操作之前。同时，它保证了在之前某个线程执行的
      release
      操作（或更强的内存序操作）所导致的所有内存写入，在当前线程的
      acquire
      操作之后都是可见的。
    • 机制: 在某些架构上，这可能意味着在
      acquire
      操作之后插入一个读屏障（Load Barrier），阻止后续的读操作越过它被提前执行。
    • 示例: 
      while (!flag.load(std::memory_order_acquire)) { /* spin */ }

  • std::memory_order_release
    :
    • 保证: 一个
      release
      操作（通常是写操作）会“释放”内存，确保该操作之前的所有内存访问不会被重排到
      release
      操作之后。它保证了在当前线程
      release
      操作之前的所有内存写入，对其他线程的
      acquire
      操作（或更强的内存序操作）是可见的。
    • 机制: 在某些架构上，这可能意味着在
      release
      操作之前插入一个写屏障（Store Barrier），阻止之前的写操作越过它被推迟执行。
    • 示例: 
      data = 123; flag.store(true, std::memory_order_release);

  • std::memory_order_acq_rel
    :
    • 保证: 用于读-改-写（RMW）操作，同时具备
      acquire
      和
      release
      的语义。它既能看到之前
      release
      操作的写入，又能让它之前的写入对后续的
      acquire
      操作可见。
    • 机制: 结合了读屏障和写屏障的特性。
    • 示例: 
      value.fetch_add(1, std::memory_order_acq_rel);

  • std::memory_order_seq_cst
    :
    • 保证: 提供最强的内存序保证——顺序一致性。所有使用
      seq_cst
      的原子操作，在所有线程看来，都将以一个单一的、全局一致的顺序发生。
    • 机制: 通常会插入全能屏障（Full Barrier），它既是读屏障也是写屏障，并且可能涉及额外的缓存同步操作。这会带来最高的性能开销，因为它限制了编译器和CPU的优化空间。
    • 示例: 
      flag.store(true, std::memory_order_seq_cst);

通过这些不同的内存序，

std::atomic
允许开发者在性能和正确性之间做出权衡。理解它们各自的保证和开销，是编写高效且正确的并发代码的关键。简单来说，
acquire
和
release
操作协同工作，就像在两个线程之间架起了一座“桥梁”，确保了数据流动的方向和可见性。 除了std::atomic，还有哪些低级机制可以避免内存重排？

虽然

std::atomic
是C++11及更高版本中推荐的、更高级别的内存重排解决方案，但在某些特殊场景或为了理解底层机制，我们仍然会接触到一些更低级的技术。

一个值得关注的是

std::atomic_thread_fence
。它不与任何特定的数据关联，而是直接在代码中插入一个内存屏障。它同样接受
std::memory_order
参数，用于指定屏障的强度。
#include <atomic>
#include <thread>
#include <iostream>

int shared_data = 0;
std::atomic<bool> data_ready(false);

void writer_thread() {
    shared_data = 100; // 非原子写
    // 在这里插入一个release fence，确保shared_data的写入在fence之前完成，
    // 并且对后续的acquire fence可见
    std::atomic_thread_fence(std::memory_order_release); 
    data_ready.store(true, std::memory_order_relaxed); // 这里relaxed是因为fence已经提供了顺序
    std::cout << "Writer finished." << std::endl;
}

void reader_thread() {
    while (!data_ready.load(std::memory_order_relaxed)) {
        std::this_thread::yield();
    }
    // 在这里插入一个acquire fence，确保在读取shared_data之前，
    // writer_thread的release fence之前的写入已经可见
    std::atomic_thread_fence(std::memory_order_acquire);
    std::cout << "Reader got data: " << shared_data << std::endl;
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

    t1.join();
    t2.join();

    return 0;
}

在这个例子中，

std::atomic_thread_fence(std::memory_order_release)
确保了
shared_data = 100
的写入在
fence
之前完成并对其他线程可见。而
std::atomic_thread_fence(std::memory_order_acquire)
则保证了当它执行时，
writer_thread
中
release fence
之前的写入（即
shared_data = 100
）都已经对
reader_thread
可见。
data_ready
本身可以
relaxed
，因为它只是一个信号，真正的同步由
fence
来完成。

除了

std::atomic_thread_fence
，还有一些更底层的、平台相关的机制：

  • 平台特定的内存屏障指令：例如，在x86/x64架构上，有

    _mm_mfence
    （全能屏障）、
    _mm_lfence
    （读屏障）、
    _mm_sfence
    （写屏障）等CPU指令。这些通常通过编译器内联函数（intrinsics）暴露出来。它们提供了最直接的CPU控制，但缺乏可移植性，且使用起来需要非常深入的硬件知识。通常，我们应该优先使用C++标准库提供的抽象，因为它们会根据目标平台选择最合适的底层指令。

  • 互斥锁（Mutexes）和条件变量（Condition Variables）：虽然它们的主要作用是提供互斥访问和线程间的等待/通知机制，但它们在实现上通常也包含了隐式的内存屏障。例如，当一个线程释放一个互斥锁时，它通常会执行一个

    release
    语义的操作；当另一个线程获取同一个互斥锁时，它会执行一个
    acquire
    语义的操作。这意味着，在锁的保护下进行的所有内存操作，其可见性会得到保证。这也是为什么在多线程编程中，只要正确使用互斥锁，通常就不需要额外考虑内存重排的问题。它们为我们提供了一个更高级别的、更易于使用的同步抽象。

理解这些低级机制有助于我们更好地理解

std::atomic
的工作原理，但在实际开发中，除非有极其特殊的性能或兼容性需求，否则坚持使用C++标准库提供的
std::atomic
和
std::atomic_thread_fence
是更安全、更可移植、更推荐的做法。它们已经为我们处理了大部分底层平台的复杂性。

以上就是C++如何在多线程中避免内存重排的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： c++ go 计算机 处理器 ai ios 同步机制 标准库 为什么 red 架构 数据类型 while 封装 数据结构 线程 多线程 并发 大家都在看： C++如何使用模板实现算法策略模式 C++如何处理标准容器操作异常 C++如何使用右值引用与智能指针提高效率 C++如何使用STL算法实现累加统计 C++使用VSCode和CMake搭建项目环境方法

标签:  重排 多线程 内存 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表