Java：缓存行和伪共享

在Java中，缓存行（Cache Line）和伪共享（False Sharing）是与多线程访问共享数据相关的两个重要概念。以下是关于这两个概念的详细解释：

缓存行（Cache Line）

1. 定义：缓存行是处理器中缓存的最小单位，用于存储从主内存中读取的数据块。缓存行的大小在不同的处理器架构中可能有所不同，但通常为64字节。
2. 作用：当CPU需要访问内存中的数据时，它会将数据从主内存加载到缓存行中，并在后续的操作中直接对缓存行进行读写，而不是每次都访问主内存。这可以大大提高数据的访问速度，因为CPU访问缓存的速度要比访问主内存快得多。
3. 与多线程的关系：当多个线程同时访问同一个缓存行中的不同变量时，由于缓存行的一致性要求，可能会导致其他线程的缓存行失效，从而降低性能。

伪共享（False Sharing）

1. 定义：伪共享指的是多个线程同时访问同一个缓存行中的不同变量或数据，其中至少一个线程对其中一个变量进行写操作。由于处理器缓存行的一致性协议要求缓存行中的数据在多个处理器间保持一致，因此当一个线程修改了一个变量并使得缓存行失效后，其他线程即使是访问其他变量也会受到影响。
2. 影响：伪共享会增加缓存一致性协议的开销，因为每次当某个线程修改缓存行中的数据时，都需要通知其他所有共享这个缓存行的线程，使它们的缓存行失效。这会导致其他线程需要重新从主内存中加载数据，从而降低性能。
3. 解决方案：为了避免伪共享带来的性能问题，可以使用填充（Padding）的方式。填充是在变量之间插入一些无意义的字节，使得不同变量分布在不同的缓存行中，从而避免线程冲突。此外，还可以使用Java的@Contended注解来实现填充，但需要注意的是，这个注解是Java 9中引入的，并且可能在不同的处理器架构和具体实现中表现和影响有所不同。

在Java中，要避免伪共享（False Sharing），我们通常会在共享的数据结构中添加填充（Padding），以确保每个线程访问的变量位于不同的缓存行中。下面是一个简单的示例，展示了如何在Java中使用填充来避免伪共享：

import java.util.concurrent.atomic.AtomicInteger;

// 使用填充（Padding）避免伪共享的类
public class PaddedAtomicInteger extends AtomicInteger {
    // 前填充和后填充，确保实例中的value字段单独位于一个缓存行中
    private volatile long p1, p2, p3, p4, p5, p6, p7;

    public PaddedAtomicInteger(int initialValue) {
        super(initialValue);
    }

    // 填充字段可以简单地使用以下方式初始化
    // 但实际上，它们的值并不重要，因为我们只是希望它们占用空间
    private PaddedAtomicInteger() {
        // 私有构造函数，防止实例化
    }

    // 静态内部类作为帮助器类，用于初始化填充字段
    private static class PaddingHelper {
        // 静态变量，用于确保填充字段被正确初始化
        // 在类加载时，这些静态变量会触发PaddingHelper的初始化
        // 进而确保PaddedAtomicInteger的填充字段也被初始化
        private static final long[] PADDING = new long[128]; // 假设一个缓存行是64字节，这里使用128个long（8字节）确保足够的填充

        static {
            // 初始化填充，但实际上这个操作并不重要
            // 重要的是PaddingHelper类的加载会触发填充字段的初始化
            for (int i = 0; i < PADDING.length; i++) {
                PADDING[i] = 0L;
            }
        }
    }

    // 你可以在这里添加其他方法，如果需要的话
    // ...

    // 静态代码块，确保PaddingHelper被加载
    static {
        PaddingHelper.class.desiredAssertionStatus(); // 只是一个方法来触发类加载
    }
}

// 使用示例
public class FalseSharingExample {
    public static void main(String[] args) {
        // 创建多个PaddedAtomicInteger实例，由于填充的存在，它们不太可能共享同一个缓存行
        PaddedAtomicInteger counter1 = new PaddedAtomicInteger(0);
        PaddedAtomicInteger counter2 = new PaddedAtomicInteger(0);

        // ... 使用counter1和counter2进行多线程操作 ...
    }
}
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
40
41
42
43
44
45
46
47
48
49
50
51
52

注意：在上面的示例中，填充字段（p1, p2, p3, …）被声明为volatile，但它们的值并不重要。我们添加volatile关键字只是为了确保这些字段不会被编译器优化掉，从而确保它们确实在内存中占用空间。

另外，PaddingHelper类及其静态初始化块被用来确保在PaddedAtomicInteger类被加载时，填充字段就已经被初始化。这只是一个技巧，用于确保填充字段在类实例化之前就已经存在。

但是，请注意，Java中没有直接的方式来确保一个特定的字段或对象位于特定的缓存行中。缓存行的大小和布局是依赖于硬件和JVM实现的。因此，上述的填充方法只是一种尝试来减少伪共享发生的可能性，但并不能保证在所有情况下都有效。

在高性能的并发编程中，可能还需要考虑其他因素，如缓存行对齐、无锁编程技术等，来进一步提高性能。