C错误的分享示例

False sharing发生在多个线程修改同一缓存行中的不同变量时，导致缓存失效和性能下降；1. 使用结构体填充使每个变量独占一个缓存行；2. 利用alignas或std::hardware_destructive_interference_size进行内存对齐；3. 优先使用线程本地变量最后合并结果，从而避免伪共享，提升多线程程序性能。

在多线程编程中，false sharing（伪共享）是一个常见的性能陷阱。它发生在多个线程修改位于同一缓存行（cache line）中的不同变量时，导致不必要的缓存失效和性能下降。C 中尤其容易出现这个问题，因为开发者对内存布局有直接控制。

下面是一个典型的 C false sharing 示例，以及如何修复它。

? 什么是 False Sharing？

现代 CPU 缓存以“缓存行”为单位（通常是 64 字节）加载数据。如果两个变量位于同一个缓存行中，即使它们被不同的线程独立访问，一个线程的写操作也会导致另一个线程的缓存行失效，从而强制重新从内存加载 —— 这就是伪共享。

? 伪共享示例代码

#include <thread>
#include <vector>
#include <chrono>
#include <iostream>

alignas(64) struct Counter {
    volatile long value = 0;
};

const int NUM_THREADS = 4;
const long ITERATIONS = 10'000'000;

// 多个线程共享一个数组，但每个线程操作不同元素
std::vector<Counter> counters_bad(NUM_THREADS);

void worker_bad(int tid) {
    for (long i = 0; i < ITERATIONS;   i) {
        counters_bad[tid].value  ;
    }
}

int main() {
    std::vector<std::thread> threads;

    auto start = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < NUM_THREADS;   i) {
        threads.emplace_back(worker_bad, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    std::cout << "Bad (false sharing): " << duration.count() << " ms\n";
    return 0;
}

⚠️ 虽然每个线程操作的是 counters_bad[tid]，但 Counter 结构体只用了 alignas(64) 对单个变量对齐，而 std::vector 中的元素是连续存储的。如果 Counter 没有足够填充，多个 Counter 可能挤在同一个缓存行中，造成伪共享。

但上面代码其实还不够典型，我们来写一个更清晰的对比。

? 对比：有伪共享 vs 无伪共享

#include <thread>
#include <vector>
#include <chrono>
#include <iostream>

// 方式1：容易产生 false sharing（变量太近）
struct CounterFalse {
    volatile long a = 0;
    // 没有填充，多个 CounterFalse 可能共用一个缓存行
};

// 方式2：避免 false sharing，手动填充到一个缓存行
struct CounterFixed {
    volatile long a = 0;
    char padding[64 - sizeof(long)]; // 填充到 64 字节
};

const int NUM_THREADS = 4;
const long ITERATIONS = 10'000'000;

// 测试1：False sharing 版本
std::vector<CounterFalse> counters_false(NUM_THREADS);
void worker_false(int tid) {
    for (long i = 0; i < ITERATIONS;   i) {
        counters_false[tid].a  ;
    }
}

// 测试2：无 false sharing 版本
std::vector<CounterFixed> counters_fixed(NUM_THREADS);
void worker_fixed(int tid) {
    for (long i = 0; i < ITERATIONS;   i) {
        counters_fixed[tid].a  ;
    }
}

int main() {
    std::vector<std::thread> threads;

    // 测试 false sharing
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_THREADS;   i) {
        threads.emplace_back(worker_false, i);
    }
    for (auto& t : threads) t.join();
    auto end = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "With false sharing: " << duration1.count() << " ms\n";

    threads.clear();

    // 测试 fixed version
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_THREADS;   i) {
        threads.emplace_back(worker_fixed, i);
    }
    for (auto& t : threads) t.join();
    end = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Without false sharing: " << duration2.count() << " ms\n";

    return 0;
}

? 输出示例（在多核机器上）

With false sharing: 850 ms
Without false sharing: 220 ms

可以看到，避免伪共享后性能提升显著（4倍左右）。

? 如何避免 False Sharing？

• ✅ 使用填充（padding）：确保每个线程访问的变量独占一个缓存行（通常是 64 字节）。
• ✅ 使用 alignas(64)：对结构体或变量强制对齐。
• ✅ 每个线程使用本地变量，最后合并：减少共享变量访问。
• ✅ 使用标准库提供的对齐工具（如 C 11 的 alignas 和 std::hardware_destructive_interference_size）

? C 17 引入了两个推荐常量：

• std::hardware_destructive_interference_size：避免伪共享的最小间隔（通常是缓存行大小）
• std::hardware_constructive_interference_size：建议共享的大小

示例（C 17 起）：

struct alignas(std::hardware_destructive_interference_size) Counter {
    volatile long value = 0;
};

? 总结

• False sharing 看似无害，实则严重拖慢多线程程序。
• 当多个线程频繁写入“逻辑上独立但物理上靠近”的变量时，容易触发。
• 解决方法：内存填充 对齐，确保变量不在同一缓存行。
• 在性能敏感的并行程序中（如高频计数、并发统计），必须注意此问题。

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

以上是C错误的分享示例的详细内容。更多信息请关注PHP中文网其他相关文章！