什么是伪共享

为了解决计算机系统中主内存与 CPU 之间运行速度差问题，会在 CPU 与主内存之间添加一级或者多级高速缓冲存储器（Cache）。这个 Cache 一般是被集成到 CPU 内部的，所以也叫 CPU Cache，图 2-6 所示是两级 Cache 结构。

伪共享 - 图1

图 2-6

在 Cache 内部是按行存储的，其中每一行称为一个 Cache 行。Cache 行（如图 2-7 所示）是 Cache 与主内存进行数据交换的单位，Cache 行的大小一般为 2 的幂次数字节。

伪共享 - 图2

图 2-7

当 CPU 访问某个变量时，首先会去看 CPU Cache 内是否有该变量，如果有则直接从中获取，否则就去主内存里面获取该变量，然后把该变量所在内存区域的一个 Cache 行大小的内存复制到 Cache 中。由于存放到 Cache 行的是内存块而不是单个变量，所以可能会把多个变量存放到一个 Cache 行中。当多个线程同时修改一个缓存行里面的多个变量时，由于同时只能有一个线程操作缓存行，所以相比将每个变量放到一个缓存行，性能会有所下降，这就是伪共享，如图 2-8 所示。

伪共享 - 图3

图 2-8

在该图中，变量 x 和 y 同时被放到了 CPU 的一级和二级缓存，当线程 1 使用 CPU1 对变量 x 进行更新时，首先会修改 CPU1 的一级缓存变量 x 所在的缓存行，这时候在缓存一致性协议下，CPU2 中变量 x 对应的缓存行失效。那么线程 2 在写入变量 x 时就只能去二级缓存里查找，这就破坏了一级缓存。而一级缓存比二级缓存更快，这也说明了多个线程不可能同时去修改自己所使用的 CPU 中相同缓存行里面的变量。更坏的情况是，如果 CPU 只有一级缓存，则会导致频繁地访问主内存。

为何会出现伪共享

伪共享的产生是因为多个变量被放入了一个缓存行中，并且多个线程同时去写入缓存行中不同的变量。那么为何多个变量会被放入一个缓存行呢？其实是因为缓存与内存交换数据的单位就是缓存行，当 CPU 要访问的变量没有在缓存中找到时，根据程序运行的局部性原理，会把该变量所在内存中大小为缓存行的内存放入缓存行。

  1. long a;
  2. long b;
  3. long c;
  4. long d;

如上代码声明了四个 long 变量，假设缓存行的大小为 32 字节，那么当 CPU 访问变量 a 时，发现该变量没有在缓存中，就会去主内存把变量 a 以及内存地址附近的 b、c、d 放入缓存行。也就是地址连续的多个变量才有可能会被放到一个缓存行中。当创建数组时，数组里面的多个元素就会被放入同一个缓存行。那么在单线程下多个变量被放入同一个缓存行对性能有影响吗？其实在正常情况下单线程访问时将数组元素放入一个或者多个缓存行对代码执行是有利的，因为数据都在缓存中，代码执行会更快，请对比下面代码的执行。

代码（1）

  1. public class TestForContent {
  2.     static final int LINE_NUM = 1024;
  3.     static final int COLUM_NUM = 1024;
  4.     public static void main(String[] args) {
  5.         long [][] array = new long[LINE_NUM][COLUM_NUM];
  6.         long startTime = System.currentTimeMillis();
  7.         for(int i =0; i<LINE_NUM; ++i){
  8.             for(int j=0; j<COLUM_NUM; ++j){
  9.                 array[i][j] = i＊2+j;
  10.             }
  11.         }
  12.         long endTime = System.currentTimeMillis();
  13.         long cacheTime = endTime - startTime;
  14.         System.out.println("cache time:" + cacheTime);
  15.     }
  16. }

代码（2）

  1. public class TestForContent2 {
  2.     static final int LINE_NUM = 1024;
  3.     static final int COLUM_NUM = 1024;
  4.     public static void main(String[] args) {
  5.         long [][] array = new long[LINE_NUM][COLUM_NUM];
  6.         long startTime = System.currentTimeMillis();
  7.         for(int i =0; i<COLUM_NUM; ++i){
  8.             for(int j=0; j<LINE_NUM; ++j){
  9.                 array[j][i] = i＊2+j;
  10.             }
  11.         }
  12.         long endTime = System.currentTimeMillis();
  13.         System.out.println("no cache time:" + (endTime - startTime));
  14.     }
  15. }

在笔者的 mac 电脑上执行代码（1）多次，耗时均在 10ms 以下，执行代码（2）多次，耗时均在 10ms 以上。显然代码（1）比代码（2）执行得快，这是因为数组内数组元素的内存地址是连续的，当访问数组第一个元素时，会把第一个元素后的若干元素一块放入缓存行，这样顺序访问数组元素时会在缓存中直接命中，因而就不会去主内存读取了，后续访问也是这样。也就是说，当顺序访问数组里面元素时，如果当前元素在缓存没有命中，那么会从主内存一下子读取后续若干个元素到缓存，也就是一次内存访问可以让后面多次访问直接在缓存中命中。而代码（2）是跳跃式访问数组元素的，不是顺序的，这破坏了程序访问的局部性原则，并且缓存是有容量控制的，当缓存满了时会根据一定淘汰算法替换缓存行，这会导致从内存置换过来的缓存行的元素还没等到被读取就被替换掉了。

所以在单个线程下顺序修改一个缓存行中的多个变量，会充分利用程序运行的局部性原则，从而加速了程序的运行。而在多线程下并发修改一个缓存行中的多个变量时就会竞争缓存行，从而降低程序运行性能。

如何避免伪共享

在 JDK 8 之前一般都是通过字节填充的方式来避免该问题，也就是创建一个变量时使用填充字段填充该变量所在的缓存行，这样就避免了将多个变量存放在同一个缓存行中，例如如下代码。

  1.     public final static class FilledLong {
  2.           public volatile long value = 0L;
  3.           public long p1, p2, p3, p4, p5, p6;
  4.       }

假如缓存行为 64 字节，那么我们在 FilledLong 类里面填充了 6 个 long 类型的变量，每个 long 类型变量占用 8 字节，加上 value 变量的 8 字节总共 56 字节。另外，这里 FilledLong 是一个类对象，而类对象的字节码的对象头占用 8 字节，所以一个 FilledLong 对象实际会占用 64 字节的内存，这正好可以放入一个缓存行。

JDK 8 提供了一个 sun.misc.Contended 注解，用来解决伪共享问题。将上面代码修改为如下。

  1.     @sun.misc.Contended
  2.       public final static class FilledLong {
  3.             public volatile long value = 0L;
  4.         }

在这里注解用来修饰类，当然也可以修饰变量，比如在 Thread 类中。

  1.     /＊＊ The current seed for a ThreadLocalRandom ＊/
  2.     @sun.misc.Contended("tlr")
  3.     long threadLocalRandomSeed;
  4.     /＊＊ Probe hash value; nonzero if threadLocalRandomSeed initialized ＊/
  5.     @sun.misc.Contended("tlr")
  6.     int threadLocalRandomProbe;
  7.     /＊＊ Secondary seed isolated from public ThreadLocalRandom sequence ＊/
  8.     @sun.misc.Contended("tlr")
  9.     int threadLocalRandomSecondarySeed;

Thread 类里面这三个变量默认被初始化为 0，这三个变量会在 ThreadLocalRandom 类中使用，后面章节会专门讲解 ThreadLocalRandom 的实现原理。

需要注意的是，在默认情况下，@Contended 注解只用于 Java 核心类，比如 rt 包下的类。如果用户类路径下的类需要使用这个注解，则需要添加 JVM 参数：-XX:-RestrictContended。填充的宽度默认为 128，要自定义宽度则可以设置-XX:ContendedPaddingWidth 参数。

小结

本节讲述了伪共享是如何产生的，以及如何避免，并证明在多线程下访问同一个缓存行的多个变量时才会出现伪共享，在单线程下访问一个缓存行里面的多个变量反而会对程序运行起到加速作用。本节的这些知识为后面高级篇讲解的 LongAdder 的实现原理奠定了基础。