极致性能优化之道之消除伪共享

“不积跬步，无以至千里。”

引言

在并发编程中，伪共享（False Sharing）是一种性能问题，特别是在多核处理器上。这个问题通常出现在多个线程同时修改彼此不同但共享同一缓存行的数据。为了解决伪共享问题，我们需要采用一些技术手段，特别是在Java中，使用合适的填充技术可以有效提高性能。

什么是伪共享？

伪共享是由于缓存行的概念引起的。现代计算机架构中，缓存被分割成一些大小固定的缓存行，通常为64字节。多个线程可能在不同的核上同时访问同一缓存行的不同部分，这导致了缓存行的频繁无效化和刷新，从而降低了性能。

为什么伪共享是一个问题？

伪共享导致了缓存行的频繁无效化和刷新，从而增加了线程之间的通信开销，降低了程序的性能。在多核处理器上，不同核的缓存可能同时包含相同缓存行的不同部分，当一个核修改了其中一个部分时，其他核不得不无效化整个缓存行，即使它们修改的是不同的变量。这就是伪共享问题的本质。

Java中的填充技术

1. Volatile修饰符

在Java中，我们可以使用volatile关键字修饰共享的变量，以确保线程之间的可见性。volatile不仅会防止编译器进行指令重排序，还会禁止缓存的使用，从而避免了伪共享问题。

volatile关键字在Java中用于确保多线程之间的可见性。它的工作原理是禁止线程对被volatile修饰的变量进行本地缓存，每次访问该变量时都会从主内存中重新读取。这样可以防止线程读取过期的值，从而避免了伪共享问题。

然而，volatile并不总是适用于所有场景。它的代价是性能相对较低，因为它需要频繁地从主内存中读取变量的值。在某些高性能要求的场景下，使用其他技术可能更为合适。

public class VolatileExample {
    private volatile long sharedValue;

    // 省略其他代码

    public long getSharedValue() {
        return sharedValue;
    }

    public void setSharedValue(long value) {
        this.sharedValue = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 缓存行填充

为了避免多个共享变量被放置在同一缓存行中，我们可以在它们之间插入一些无用的填充变量，使它们在不同的缓存行中。

缓存行填充的原理是在共享变量之间插入一些无用的填充变量，使它们位于不同的缓存行中。这样可以确保每个线程修改自己的变量时，不会影响其他线程的变量，从而避免了缓存行的频繁无效化和刷新。

在示例中，我们添加了一些padding变量，这些变量不参与实际的业务逻辑，只是为了填充缓存行。这样，即使多个线程同时访问不同的变量，它们仍然位于不同的缓存行中，不会发生伪共享问题。

public class PaddedExample {
    private long sharedValue;

    // 避免伪共享，添加填充变量
    private long padding1, padding2, padding3, padding4, padding5, padding6, padding7;

    // 省略其他代码

    public long getSharedValue() {
        return sharedValue;
    }

    public void setSharedValue(long value) {
        this.sharedValue = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 使用@Contended注解

从Java 8开始，JVM引入了@Contended注解，用于告诉JVM在变量的周围插入填充。需要注意的是，为了启用@Contended的效果，需要在JVM启动时添加参数-XX:-RestrictContended。

@Contended注解是JVM提供的一种消除伪共享的手段。通过在变量上添加该注解，JVM会在变量周围插入填充，以确保不同变量位于不同的缓存行中。

需要注意的是，为了启用@Contended的效果，需要在JVM启动时添加参数-XX:-RestrictContended。这是因为在某些情况下，默认情况下JVM可能会禁用@Contended的效果，以提高性能。

import java.util.concurrent.atomic.AtomicLong;

public class ContendedExample {
    @sun.misc.Contended("group1")
    private long sharedValue;

    // 省略其他代码

    public long getSharedValue() {
        return sharedValue;
    }

    public void setSharedValue(long value) {
        this.sharedValue = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

示例与最佳实践

为了演示上述技术的使用，考虑一个多线程更新共享计数器的场景。我们将使用AtomicLong作为计数器，并比较不同技术的性能。

import java.util.concurrent.atomic.AtomicLong;

public class SharedCounter {
    private volatile long volatileCounter;
    private long paddedCounter;
    private long contendedCounter;

    public SharedCounter() {
        volatileCounter = 0;
        paddedCounter = 0;
        contendedCounter = 0;
    }

    // 示例中的其他方法

    public void incrementVolatile() {
        volatileCounter++;
    }

    public long getVolatileCounter() {
        return volatileCounter;
    }

    public void incrementPadded() {
        paddedCounter++;
    }

    public long getPaddedCounter() {
        return paddedCounter;
    }

    public void incrementContended() {
        contendedCounter++;
    }

    public long getContendedCounter() {
        return contendedCounter;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

通过这个示例，我们可以使用不同的技术来更新计数器并比较它们的性能。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        SharedCounter sharedCounter = new SharedCounter();

        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 使用volatile
        executorService.submit(() -> {
            for (int i = 0; i < 1_000_000; i++) {
                sharedCounter.incrementVolatile();
            }
        });

        // 使用填充
        executorService.submit(() -> {
            for (int i = 0; i < 1_000_000; i++) {
                sharedCounter.incrementPadded();
            }
        });

        // 使用@Contended
        executorService.submit(() -> {
            for (int i = 0; i < 1_000_000; i++) {
                sharedCounter.incrementContended();
            }
        });

        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MINUTES);

        System.out.println("Volatile Counter: " + sharedCounter.getVolatileCounter());
        System.out.println("Padded Counter: " + sharedCounter.getPaddedCounter());
        System.out.println("Contended Counter: " + sharedCounter.getContendedCounter());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

性能比较和最佳实践

在实际应用中，选择合适的技术取决于具体的需求和场景。以下是一些建议：

1. 如果可见性是主要关注点，而性能相对较次要，可以考虑使用volatile关键字。
2. 如果性能是关键问题，可以使用缓存行填充技术。在添加填充变量时，需要根据实际硬件架构调整填充的字节数，以确保变量位于不同的缓存行。
3. 如果你使用的是Java 8及以上，并且JVM支持@Contended注解，可以尝试使用该注解。但请注意，启用@Contended可能会增加内存消耗，因此需要在内存和性能之间进行权衡。
4. 在实际应用中，最佳实践是通过性能测试来评估不同技术的效果。使用性能分析工具和测量工具，例如JMH（Java Microbenchmarking Harness），来获取详细的性能数据。

综上所述，消除伪共享是一个需要综合考虑可维护性和性能的问题。选择合适的技术取决于具体的应用场景和需求，通过权衡不同技术的优缺点，可以找到最适合的解决方案。

结论

通过使用volatile、缓存行填充和@Contended等技术，我们可以有效地消除伪共享问题，提高并发程序的性能。在选择哪种技术时，需要根据具体的应用场景和性能要求进行权衡。最佳实践是根据具体情况进行性能测试，以确定哪种技术最适合你的应用。在实际开发中，根据具体情况选择最适合的优化手段，以确保高性能和可维护性的平衡。