JVM之缓存行对齐

缓存行

缓存是由多个缓存行组成的，以缓存行为基本单位，一个缓存行的大小一般为64字节。

伪共享

因为缓存行存在，当不同的线程在操作两份不同的数据时，如果这两份数据刚好位于同一个缓存行中，那么彼此之间就会互相影响。

假设A线程操作数据C，B线程操作数据D，C、D数据位于同一缓存行，那么当C数据发生修改时，由于缓存一致性协议的规定，就会造成缓存行失效，那么当B线程操作D数据时，就必须重新加载缓存，尽管B线程之前并没有对D进行过任何操作，同理B线程的操作同样会影响着A线程。

缓存行对齐

所以为了解决伪共享的问题，就出现了缓存行对齐的方式，也就是让C、D两份数据分别独占一个缓存行，这样就不会互相影响了。

如果要了解缓存，就必须要了解缓存的结构，以及多个cpu核心访问缓存存在的一些问题和注意事项。

 

 

 

 

每个缓存里面都是由缓存行组成的，缓存系统中以缓存行（cache line）为单位存储的。缓存行大小是64字节。由于缓存行的特性，当多线程修改互相独立的变量时，如果这些变量共享同一个缓存行，就会无意中影响彼此的性能，这就是伪共享（下面会介绍到）。有人将伪共享描述成无声的性能杀手，因为从代码中很难看清楚是否会出现伪共享问题。

需要注意，数据在缓存中不是以独立的项来存储的，它不是我们认为的一个独立的变量，也不是一个单独的指针，它是有效引用主存中的一块地址。一个Java的long类型是8字节，因此在一个缓存行中可以存8个long类型的变量。

 

 

 缓存行的这种特性也决定了在访问同一缓存行中的数据时效率是比较高的。比如当你访问java中的一个long类型的数组，当数组中的一个值被加载到缓存中，它会额外加载另外7个，因此可以非常快速的遍历这个数组。实际上，你可以非常快速的遍历在连续的内存块中分配的任意数据结构。

 

处理器为了提高处理速度，不直接和内存进行通讯，而是先将系统内存的数据读到内部缓存（L1,L2,L3）后再进行操作，但操作完之后不知道何时会写到内存；如果对声明了volatile 变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在的缓存行的数据写回到系统内存。但就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题，所以在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读取到处理器缓存里。

为了说明伪共享问题，下面举一个例子进行说明：两个线程分别对两个变量（刚好在同一个缓存航）分别进行读写的情况分析。

 

 

 

 

在core1上线程需要更新变量X,同时core2上线程需要更新变量Y。这种情况下，两个变量就在同一个缓存行中。每个线程都要去竞争缓存行的所有权来更新对应的变量。如果core1获得了缓存行的所有权，那么缓存子系统将会使core2中对应的缓存失效。相反，如果core2获得了所有权然后执行更新操作，core1就要使自己对应的缓存行失效。这里需要注意：整个操作过程是以缓存行为单位进行处理的，这会来来回回的经过L3缓存，大大影响了性能，每次当前线程对缓存行进行写操作时，内核都要把另一个内核上的缓存块无效掉，并重新读取里面的数据。如果相互竞争的核心位于不同的插槽，就要额外横跨插槽连接，效率可能会更低。

 

缓存行对齐（实例代码）

1：先看未使用缓存行对齐的方式

 1 package com.example.demo;
 2  
 3 public class Cacheline_nopadding {
 4     public static class T{
 5         //8字节
 6         private volatile long x = 0L;
 7     }
 8     private static T[] arr = new T[2];
 9  
10     static {
11         arr[0] = new T();
12         arr[1] = new T();
13     }
14  
15     public static void main(String[] args) throws InterruptedException {
16         Thread thread1 = new Thread(()->{
17             for(long i = 0;i < 1000_0000L;i++){
18                 //volatile的缓存一致性协议MESI或者锁总线，会消耗时间
19                 arr[0].x = i;
20             }
21         });
22  
23         Thread thread2 = new Thread(()->{
24             for(long i = 0;i< 1000_0000L;i++){
25                 arr[1].x = i;
26             }
27         });
28         long startTime = System.nanoTime();
29         thread1.start();
30         thread2.start();
31         thread1.join();
32         thread2.join();
33         System.out.println("总计消耗时间："+(System.nanoTime()-startTime)/100_000);
34     }
35 }

最终运行结果如下：

总计消耗时间：3381

下面来做一个改造升级，对齐缓存行，重点代码如下

 

1    private static class Padding{
2         //7*8字节
3         public volatile long p1,p2,p3,p4,p5,p6,p7;
4     }
5     public static class T extends Padding{
6         //8字节
7         private volatile long x = 0L;
8     }

 

通过上述代码做缓存对齐，每次都会有初始的7*8个占位，加上最后一个就是独立的一块缓存行，整理后代码如下：

 1 package com.example.demo;
 2  
 3 public class Cacheline_padding {
 4     private static class Padding{
 5         //7*8字节
 6         public volatile long p1,p2,p3,p4,p5,p6,p7;
 7     }
 8     public static class T extends Padding{
 9         //8字节
10         private volatile long x = 0L;
11     }
12     private static T[] arr = new T[2];
13  
14     static {
15         arr[0] = new T();
16         arr[1] = new T();
17     }
18  
19     public static void main(String[] args) throws InterruptedException {
20         Thread thread1 = new Thread(()->{
21             for(long i = 0;i < 1000_0000L;i++){
22                 //volatile的缓存一致性协议MESI或者锁总线，会消耗时间
23                 arr[0].x = i;
24             }
25         });
26  
27         Thread thread2 = new Thread(()->{
28             for(long i = 0;i< 1000_0000L;i++){
29                 arr[1].x = i;
30             }
31         });
32         long startTime = System.nanoTime();
33         thread1.start();
34         thread2.start();
35         thread1.join();
36         thread2.join();
37         System.out.println("总计消耗时间："+(System.nanoTime()-startTime)/100_000);
38     }
39 }

运行结果如下：

总计消耗时间：1428

从上面可以看到，使用缓存对齐，相同操作情况下对齐后的时间比没对齐的时间减少一半。

上面这种缓存行填充的方法在早期是比较流行的一种解决办法，比较有名的disruptor框架就采用了这种解决办法提高性能，disruptor是一个线程内通信框架，用于线程里共享数据。与LinkedBlockingQueue类似，提供了一个高速的生产者消费者模型，广泛用于批量IO读写，在硬盘读写相关的程序中应用十分广泛，Apache旗下的HBase、Hive、Storm等框架都有使用disruptor。

4、JAVA8对伪共享的解决

进入到JAVA8后，官方已经提供了对伪共享的解决办法，那就是sun.misc.Contended注解，有了这个注解解决伪共享就变得简单多了

1   @sun.misc.Contended
2     public static class T{
3         //8字节
4         private volatile long x = 0L;
5     }

需要注意：默认情况下此注解是无效的，需要在JVM启动时设置-XX:-RestrictContended。完整的代码如下：

 

 

 

 1 package com.example.demo;
 2  
 3 public class Cacheline_nopadding {
 4     @sun.misc.Contended
 5     public static class T{
 6         //8字节
 7         private volatile long x = 0L;
 8     }
 9     private static T[] arr = new T[2];
10  
11     static {
12         arr[0] = new T();
13         arr[1] = new T();
14     }
15  
16     public static void main(String[] args) throws InterruptedException {
17         Thread thread1 = new Thread(()->{
18             for(long i = 0;i < 1000_0000L;i++){
19                 //volatile的缓存一致性协议MESI或者锁总线，会消耗时间
20                 arr[0].x = i;
21             }
22         });
23  
24         Thread thread2 = new Thread(()->{
25             for(long i = 0;i< 1000_0000L;i++){
26                 arr[1].x = i;
27             }
28         });
29         long startTime = System.nanoTime();
30         thread1.start();
31         thread2.start();
32         thread1.join();
33         thread2.join();
34         System.out.println("总计消耗时间："+(System.nanoTime()-startTime)/100_000);
35     }
36 }

 

可以看到，只是在没有缓存对齐的代码基础上添加了一个注解而已，测试结果如下：

总计消耗时间：1289

 

本文原文出自https://blog.csdn.net/mofeizhi/article/details/106816026