C++多线程中怎样避免虚假共享 缓存行填充技术

虚假共享是指多个线程修改位于同一缓存行中的不同变量，导致缓存频繁失效，从而降低性能；其解决方法包括使用缓存行填充、alignas对齐、标准库常量或宏定义缓存行大小，确保每个线程访问的变量独占一个缓存行，尽管增加内存开销，但在高并发场景下性能提升显著。

在C++多线程编程中，虚假共享（False Sharing） 是一个容易被忽视但严重影响性能的问题。它发生在多个线程修改不同的变量，而这些变量恰好位于同一个缓存行（Cache Line）中，导致CPU缓存频繁失效，从而降低程序性能。

什么是虚假共享？

现代CPU为了提高访问速度，将内存按缓存行（通常为64字节）为单位加载到各级缓存中。当一个核心修改了某个变量，该变量所在的整个缓存行会被标记为“已修改”，其他核心中该缓存行的副本就会失效，需要重新从内存或其他核心同步。

如果两个线程分别修改位于同一缓存行中的不同变量，即使变量之间毫无关系，也会因为共享缓存行而频繁触发缓存同步，这就是虚假共享。

立即学习“C++免费学习笔记（深入）”；

如何避免虚假共享？——缓存行填充

最常用的方法是缓存行填充（Cache Line Padding），即通过在变量之间插入足够的填充字节，确保每个线程独占一个缓存行。

方法一：手动填充结构体

假设你有一个结构体，多个线程会频繁修改其中的成员：

struct Counter {
    alignas(64) int64_t value;  // 对齐到缓存行起始
    char padding[64 - sizeof(int64_t)];  // 填充到64字节
};

但更常见的是多个计数器并列的情况：

struct PaddedCounter {
    int64_t value;
    char padding[64 - sizeof(int64_t)];  // 填充至64字节
};

PaddedCounter counters[4];  // 每个计数器独占一个缓存行

这样，每个

value

方法二：使用

alignas

和结构体对齐

C++11 提供了

alignas

struct alignas(64) CounterAligned {
    int64_t value;
};

这样，每个

CounterAligned

绘蛙AI修图

绘蛙平台AI修图工具，支持手脚修复、商品重绘、AI扩图、AI换色

下载

但注意：如果数组中连续存放多个

CounterAligned

struct NoFalseSharing {
    int64_t value;
    alignas(64) char pad;  // 下一个变量会从新的缓存行开始
};

或者更清晰地：

struct NoFalseSharing {
    int64_t value;
    char padding[64 - sizeof(int64_t)];
} alignas(64);

方法三：使用标准库或宏定义缓存行大小

缓存行大小在不同平台可能不同（x86_64通常是64字节），可定义宏：

#if defined(__cpp_lib_hardware_interference_size)
    using std::hardware_destructive_interference_size;
    using std::hardware_constructive_interference_size;
#else
    // 多数平台为64字节
    constexpr size_t hardware_destructive_interference_size = 64;
#endif

struct Counter {
    int64_t value;
    char padding[hardware_destructive_interference_size - sizeof(int64_t)];
};

C++17 起引入了

std::hardware_destructive_interference_size

注意：该常量在 C++17 中被引入，但在 C++20 中被移除，因为实现困难。许多编译器仍支持，或可通过宏定义模拟。

实际例子：多个线程更新独立计数器

#include 
#include 
#include 

struct BadCase {
    int64_t a, b;  // 在同一缓存行，易发生虚假共享
};

struct GoodCase {
    int64_t a;
    char padding[64 - sizeof(int64_t)];
    int64_t b;
};

int main() {
    const int n = 10000000;

    // 测试 BadCase
    {
        BadCase c{0, 0};
        auto start = std::chrono::high_resolution_clock::now();

        std::thread t1([&]{ for (int i = 0; i < n; ++i) c.a++; });
        std::thread t2([&]{ for (int i = 0; i < n; ++i) c.b++; });

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

        auto end = std::chrono::high_resolution_clock::now();
        auto ms = std::chrono::duration_cast(end - start);
        printf("BadCase: %lld ms\n", ms.count());
    }

    // 测试 GoodCase
    {
        GoodCase c{0, {}, 0};
        auto start = std::chrono::high_resolution_clock::now();

        std::thread t1([&]{ for (int i = 0; i < n; ++i) c.a++; });
        std::thread t2([&]{ for (int i = 0; i < n; ++i) c.b++; });

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

        auto end = std::chrono::high_resolution_clock::now();
        auto ms = std::chrono::duration_cast(end - start);
        printf("GoodCase: %lld ms\n", ms.count());
    }

    return 0;
}

在多核系统上，

GoodCase

BadCase

其他建议

• 避免在循环中频繁访问跨线程共享的紧密变量
• 优先使用线程局部存储（TLS）或局部变量累加，最后合并结果
• 对于数组，可考虑每个线程使用独立的槽位（如按线程ID索引），并确保槽位间隔至少一个缓存行

例如：

alignas(64) int64_t local_sum[std::thread::hardware_concurrency()];

总结

避免虚假共享的关键是：

• 理解缓存行的工作机制（通常是64字节）
• 使用填充或对齐确保不同线程访问的变量不在同一缓存行
• 优先使用

  alignas(64)

  和填充数组
• 在性能敏感的并发计数、状态标志等场景特别注意

虽然填充会增加内存占用，但在高并发场景下，性能提升通常远超内存开销。

基本上就这些，不复杂但容易忽略。