怎么通过分析 Java 的伪共享问题优化多核 CPU 下的同步变量设计

在Java多核并发编程中，伪共享是影响同步变量性能的常见隐形问题，它的产生和CPU的缓存架构直接相关。CPU为了提升数据访问效率，会将内存中的数据按缓存行（Cache Line）为单位加载到各级缓存中，通常一个缓存行的大小是64字节。

伪共享的底层产生原理

当两个线程分别修改位于同一个64字节缓存行中的两个不同变量时，就会出现伪共享。比如线程A修改了变量X，线程B修改了变量Y，而X和Y恰好在同一个缓存行内。此时线程A修改X会导致整个缓存行被标记为无效，线程B如果要修改Y就需要重新从内存加载这个缓存行，反之亦然，两个线程的修改操作会互相干扰，带来额外的缓存同步开销。

我们可以通过一个简单的示例来模拟伪共享的场景，下面的代码定义了两个相邻的int变量，两个线程分别修改这两个变量：

public class FalseSharingDemo {
    // 两个int变量，默认情况下会相邻存储在内存中
    private int value1;
    private int value2;

    public void incrementValue1() {
        for (int i = 0; i < 100000000; i++) {
            value1++;
        }
    }

    public void incrementValue2() {
        for (int i = 0; i < 100000000; i++) {
            value2++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FalseSharingDemo demo = new FalseSharingDemo();
        Thread t1 = new Thread(demo::incrementValue1);
        Thread t2 = new Thread(demo::incrementValue2);

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("执行耗时：" + (end - start) + "毫秒");
    }
}

运行上述代码，你会发现两个线程同时修改相邻变量的耗时，比两个线程分别修改不在同一个缓存行内的变量耗时更长，这就是伪共享带来的性能损耗。

如何检测Java中的伪共享问题

要优化伪共享，首先需要能够检测到它的存在，常用的检测方式有以下几种：

• 使用性能分析工具：比如Java Mission Control、AsyncProfiler等工具，可以查看CPU缓存的命中率、缓存行失效的次数等指标，定位是否存在伪共享问题。
• 代码逻辑排查：如果多个频繁修改的变量被定义在一起，且这些变量会被不同的线程访问，就大概率存在伪共享风险。
• 对比测试：将变量调整到不在同一个缓存行后运行程序，对比性能变化，如果性能有明显提升，说明之前存在伪共享问题。

优化多核CPU下同步变量设计的方案

1. 使用缓存行填充（Padding）

缓存行填充是最常用的伪共享优化方式，通过在变量前后填充无用的字节，让目标变量独占一个缓存行，避免和其他变量共享。在Java中可以通过手动填充或者注解的方式实现。

手动填充的示例如下，我们在目标变量前后填充足够多的字节，确保变量占据整个64字节的缓存行：

public class PaddingOptimizedDemo {
    // 缓存行填充，前面的填充字节
    private long p1, p2, p3, p4, p5, p6, p7;
    // 目标同步变量
    private int value1;
    // 后面的填充字节
    private long p8, p9, p10, p11, p12, p13, p14, p15;

    private int value2;

    public void incrementValue1() {
        for (int i = 0; i < 100000000; i++) {
            value1++;
        }
    }

    public void incrementValue2() {
        for (int i = 0; i < 100000000; i++) {
            value2++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        PaddingOptimizedDemo demo = new PaddingOptimizedDemo();
        Thread t1 = new Thread(demo::incrementValue1);
        Thread t2 = new Thread(demo::incrementValue2);

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("优化后执行耗时：" + (end - start) + "毫秒");
    }
}

注意填充的字节数需要根据缓存行大小调整，一般64字节的缓存行，填充到变量前后总共补充足够的字节即可，不同JVM版本可能有差异，需要实际测试。

2. 使用@Contended注解

Java 8及以上版本提供了@Contended注解，它可以自动为被标注的字段或类进行缓存行填充，不需要手动计算填充字节数。使用该注解需要开启JVM参数-XX:-RestrictContended，否则注解不会生效。

使用@Contended注解的示例如下：

import sun.misc.Contended;

public class ContendedOptimizedDemo {
    // 使用@Contended注解，让value1独占缓存行
    @Contended
    private int value1;

    @Contended
    private int value2;

    public void incrementValue1() {
        for (int i = 0; i < 100000000; i++) {
            value1++;
        }
    }

    public void incrementValue2() {
        for (int i = 0; i < 100000000; i++) {
            value2++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ContendedOptimizedDemo demo = new ContendedOptimizedDemo();
        Thread t1 = new Thread(demo::incrementValue1);
        Thread t2 = new Thread(demo::incrementValue2);

        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("使用@Contended后执行耗时：" + (end - start) + "毫秒");
    }
}

需要注意的是@Contended注解在Java 9之后被移到了jdk.internal.vm.annotation包下，如果是高版本JDK需要调整导入的包路径，同时生产环境开启对应的JVM参数需要评估影响。

3. 合理拆分同步变量的存储结构

如果多个同步变量不需要强关联，可以将它们拆分到不同的对象实例中，避免它们被存储在相邻的内存空间，从根源上减少共享同一个缓存行的可能。比如原本在一个类中定义多个线程频繁修改的变量，可以将这些变量拆分到不同的类中，每个类的实例只被一个线程修改，就不会出现伪共享问题。

优化时的注意事项

• 不是所有的多变量场景都需要优化伪共享：如果变量的修改频率很低，或者访问这些变量的线程很少，伪共享带来的开销可以忽略，不需要额外做填充优化，避免增加不必要的内存占用。
• 填充的字节数要适配目标环境的缓存行大小：不同CPU的缓存行大小可能不同，常见的x86架构是64字节，部分架构可能是32字节或者128字节，优化前需要确认目标环境的缓存行大小。
• 避免过度优化：缓存行填充会增加对象的内存占用，如果大量对象都做填充，可能会导致内存占用过高，触发更频繁的GC，反而影响性能。

通过上述方式分析并优化Java中的伪共享问题，可以有效减少多核CPU下的缓存同步开销，提升同步变量的访问性能，让并发程序在多核环境下发挥更好的性能表现。

Java伪共享False_Sharing多核CPU同步变量修改时间：2026-06-16 07:24:36