Java 中的伪共享（False Sharing）：通过 @Contended 注解避免缓存行竞争
各位同学，大家好。今天我们来深入探讨一个在并发编程中经常被忽略，但却能显著影响性能的问题——伪共享（False Sharing），以及如何利用 @Contended 注解来缓解这个问题。
1. 什么是伪共享？
在多核处理器架构中，每个核心都有自己的高速缓存（Cache）。CPU 读取内存数据时，会将一部分内存数据加载到缓存中，以便下次快速访问。为了提高效率，缓存并不是以单个字节为单位进行加载，而是以缓存行（Cache Line）为单位。典型的缓存行大小是 64 字节。
伪共享是指多个线程访问不同的变量，但这些变量恰好位于同一个缓存行中，导致缓存一致性协议（例如 MESI）不断地在各个核心之间同步缓存行，从而降低性能。
简单来说，就是“明明访问的是不同的数据，却因为它们住在一个‘房间’里，导致大家互相干扰”。
举个例子：
假设我们有两个线程分别操作变量 a 和 b，这两个变量都位于同一个缓存行中。当线程 1 修改了 a，即使线程 2 正在读取 b，也会触发缓存一致性协议，导致线程 2 的缓存行失效，需要重新从主内存加载，从而降低了线程 2 的读取速度。
public class FalseSharingExample {
private static final int NUM_THREADS = 2;
private static final long ITERATIONS = 100_000_000L;
private static class Value {
public volatile long value = 0L;
}
private static Value[] values;
public static void main(String[] args) throws InterruptedException {
values = new Value[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
values[i] = new Value();
}
Thread[] threads = new Thread[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
final int index = i;
threads[i] = new Thread(() -> {
long start = System.nanoTime();
for (long j = 0; j < ITERATIONS; j++) {
values[index].value = j;
}
long end = System.nanoTime();
System.out.println("Thread " + index + " took " + (end - start) / 1_000_000 + " ms");
});
}
long start = System.nanoTime();
for (Thread thread : threads) {
thread.start();
}
for (Thread thread : threads) {
thread.join();
}
long end = System.nanoTime();
System.out.println("Total time: " + (end - start) / 1_000_000 + " ms");
}
}在这个例子中，两个线程分别修改 values[0].value 和 values[1].value。如果 values[0] 和 values[1] 在内存中相邻，并且位于同一个缓存行中，那么就会发生伪共享。
2. 如何检测伪共享？
检测伪共享通常比较困难，因为它涉及到硬件层面的细节。以下是一些可以用来检测伪共享的方法：
- 性能分析工具： 使用性能分析工具（例如 Intel VTune Amplifier, perf）可以分析 CPU 的缓存行为，例如缓存未命中率（Cache Miss Rate）。如果缓存未命中率很高，可能存在伪共享。
- 统计缓存行失效次数： 一些底层的性能计数器可以统计缓存行失效的次数。如果某个线程导致其他线程的缓存行频繁失效，那么可能存在伪共享。
- 代码审查： 通过仔细审查代码，可以发现可能导致伪共享的变量访问模式。例如，多个线程访问相邻的变量，并且这些变量可能会被频繁修改。
- 对比实验： 通过调整变量的内存布局，例如增加填充（padding），可以减少伪共享的可能性。对比调整前后的性能，可以评估伪共享的影响。
3. 如何避免伪共享？
避免伪共享的关键在于确保被不同线程频繁访问的变量位于不同的缓存行中。以下是一些常用的方法：
-
填充（Padding）： 在变量之间增加填充，使得它们位于不同的缓存行中。
private static class Value { public volatile long value = 0L; public long p1, p2, p3, p4, p5, p6, p7; // Padding }这种方法简单直接，但是会增加内存占用。
-
对象对齐： 确保对象的起始地址与缓存行对齐。这可以通过一些技巧来实现，例如使用 Unsafe 类。
-
@Contended 注解： 在 Java 8 之后，可以使用
@Contended注解来告诉 JVM，需要将该变量放置在独立的缓存行中。
4. @Contended 注解详解
@Contended 注解是 JDK 8 中新增的一个用于避免伪共享的工具。它来自 jdk.internal.vm.annotation 包，默认情况下是隐藏的，需要通过 JVM 参数来启用。
启用 @Contended 注解：
需要在 JVM 启动参数中添加 -XX:-RestrictContended。 默认情况下，RestrictContended是开启的，意味着@Contended注解无效。将其设置为false，才能启用@Contended注解。
使用 @Contended 注解：
将 @Contended 注解添加到需要避免伪共享的变量上。
import jdk.internal.vm.annotation.Contended;
public class ContendedExample {
private static final int NUM_THREADS = 2;
private static final long ITERATIONS = 100_000_000L;
@Contended
private static class Value {
public volatile long value = 0L;
}
private static Value[] values;
public static void main(String[] args) throws InterruptedException {
values = new Value[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
values[i] = new Value();
}
Thread[] threads = new Thread[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
final int index = i;
threads[i] = new Thread(() -> {
long start = System.nanoTime();
for (long j = 0; j < ITERATIONS; j++) {
values[index].value = j;
}
long end = System.nanoTime();
System.out.println("Thread " + index + " took " + (end - start) / 1_000_000 + " ms");
});
}
long start = System.nanoTime();
for (Thread thread : threads) {
thread.start();
}
for (Thread thread : threads) {
thread.join();
}
long end = System.nanoTime();
System.out.println("Total time: " + (end - start) / 1_000_000 + " ms");
}
}在这个例子中，我们在 Value 类上添加了 @Contended 注解。这将告诉 JVM，需要将 Value 类的实例放置在独立的缓存行中，从而避免伪共享。
@Contended 注解的原理：
@Contended 注解的实现原理是在对象的前后增加填充，使得对象位于独立的缓存行中。JVM 会根据缓存行的大小自动计算填充的大小。
@Contended 注解的限制：
@Contended注解只能应用于类的声明上，不能应用于类的字段上。@Contended注解只能应用于 Java 核心库的类上，不能应用于自定义的类上。如果需要应用于自定义的类上，需要将该类放置在jdk.internal.vm.annotation包中。强烈不建议这样做，因为它会破坏 Java 的模块化。@Contended注解需要在 JVM 启动参数中启用。
@Contended 注解的优势：
- 使用简单，只需要添加一个注解即可。
- 不需要手动计算填充的大小，JVM 会自动计算。
- 可以避免伪共享，提高并发性能。
@Contended 注解的注意事项：
- 使用
@Contended注解会增加内存占用。 - 过度使用
@Contended注解可能会导致内存浪费。 - 需要根据实际情况选择是否使用
@Contended注解。
5. 深入理解缓存一致性协议（MESI）
为了更好地理解伪共享，我们需要了解缓存一致性协议。最常见的缓存一致性协议是 MESI 协议。MESI 是四个状态的缩写：
- Modified（已修改）： 缓存行中的数据已经被修改，并且只存在于当前 CPU 的缓存中。
- Exclusive（独占）： 缓存行中的数据只存在于当前 CPU 的缓存中，并且数据与主内存中的数据一致。
- Shared（共享）： 缓存行中的数据存在于多个 CPU 的缓存中，并且数据与主内存中的数据一致。
- Invalid（无效）： 缓存行中的数据无效。
当一个 CPU 需要读取一个数据时，它会首先检查自己的缓存中是否存在该数据。如果存在，则直接从缓存中读取。如果不存在，则需要从主内存中读取，并将数据加载到缓存中。
当一个 CPU 需要修改一个数据时，它会首先检查自己的缓存中是否存在该数据。如果存在，则将缓存行标记为 Modified 状态，并修改数据。如果不存在，则需要从主内存中读取数据，并将数据加载到缓存中，然后将缓存行标记为 Modified 状态，并修改数据。
当一个 CPU 修改了一个数据时，它需要通知其他 CPU，使得其他 CPU 的缓存行失效。这就是缓存一致性协议的作用。
在伪共享的情况下，多个 CPU 频繁地修改同一个缓存行中的不同变量，导致缓存一致性协议不断地在各个 CPU 之间同步缓存行，从而降低性能。
6. 代码示例：使用 Padding 避免伪共享
public class PaddingExample {
private static final int NUM_THREADS = 2;
private static final long ITERATIONS = 100_000_000L;
private static class Value {
public volatile long value = 0L;
}
private static class PaddedValue {
public volatile long value = 0L;
public long p1, p2, p3, p4, p5, p6, p7; // Padding
}
private static Value[] values;
private static PaddedValue[] paddedValues;
public static void main(String[] args) throws InterruptedException {
// Without Padding
values = new Value[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
values[i] = new Value();
}
Thread[] threadsWithoutPadding = new Thread[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
final int index = i;
threadsWithoutPadding[i] = new Thread(() -> {
long start = System.nanoTime();
for (long j = 0; j < ITERATIONS; j++) {
values[index].value = j;
}
long end = System.nanoTime();
System.out.println("Thread " + index + " (Without Padding) took " + (end - start) / 1_000_000 + " ms");
});
}
long startWithoutPadding = System.nanoTime();
for (Thread thread : threadsWithoutPadding) {
thread.start();
}
for (Thread thread : threadsWithoutPadding) {
thread.join();
}
long endWithoutPadding = System.nanoTime();
System.out.println("Total time (Without Padding): " + (endWithoutPadding - startWithoutPadding) / 1_000_000 + " ms");
// With Padding
paddedValues = new PaddedValue[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
paddedValues[i] = new PaddedValue();
}
Thread[] threadsWithPadding = new Thread[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) {
final int index = i;
threadsWithPadding[i] = new Thread(() -> {
long start = System.nanoTime();
for (long j = 0; j < ITERATIONS; j++) {
paddedValues[index].value = j;
}
long end = System.nanoTime();
System.out.println("Thread " + index + " (With Padding) took " + (end - start) / 1_000_000 + " ms");
});
}
long startWithPadding = System.nanoTime();
for (Thread thread : threadsWithPadding) {
thread.start();
}
for (Thread thread : threadsWithPadding) {
thread.join();
}
long endWithPadding = System.nanoTime();
System.out.println("Total time (With Padding): " + (endWithPadding - startWithPadding) / 1_000_000 + " ms");
}
}在这个例子中，我们分别测试了有填充和没有填充的情况。通过运行这个例子，可以看到，在有填充的情况下，性能会明显提升。
7. 不同方法的比较
| 方法 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 填充（Padding） | 简单易懂，不需要额外的依赖。 | 增加内存占用，需要手动计算填充的大小。 | 适用于对内存占用不敏感，且可以手动计算填充大小的场景。 |
| 对象对齐 | 可以避免填充带来的内存浪费。 | 实现复杂，需要使用 Unsafe 类。 | 适用于对内存占用敏感，且需要高性能的场景。 |
| @Contended 注解 | 使用简单，JVM 自动计算填充的大小。 | 需要启用 JVM 参数，只能应用于 Java 核心库的类上，会增加内存占用，过度使用可能造成浪费。 | 适用于对内存占用不敏感，且需要避免伪共享的场景。 |
8. 总结与建议
伪共享是一个在并发编程中容易被忽略，但却能显著影响性能的问题。通过了解缓存一致性协议和伪共享的原理，我们可以更好地避免伪共享。
@Contended 注解是一个方便的工具，可以用来避免伪共享。但是，在使用 @Contended 注解时，需要注意其限制和注意事项。
在实际开发中，我们需要根据实际情况选择合适的避免伪共享的方法。
核心要点:
- 伪共享是由于多个线程访问位于同一缓存行的不同变量导致的。
- 可以使用填充、对象对齐或
@Contended注解来避免伪共享。 - 选择合适的方法需要考虑内存占用、实现复杂度和适用场景。
希望今天的讲解对大家有所帮助。 谢谢！