你的位置:首页 > Java教程

[Java教程]伪共享和缓存行填充,从Java 6, Java 7 到Java 8

关于伪共享的文章已经很多了,对于多线程编程来说,特别是多线程处理列表和数组的时候,要非常注意伪共享的问题。否则不仅无法发挥多线程的优势,还可能比单线程性能还差。随着JAVA版本的更新,再各个版本上减少伪共享的做法都有区别,一不小心代码可能就失效了,要注意进行测试。这篇文章总结一下。

 

什么是伪共享

关于伪共享讲解最清楚的是这篇文章《剖析Disruptor:为什么会这么快?(三)伪共享》,我这里就直接摘抄其对伪共享的解释:

 

缓存系统中是以缓存行(cache line)为单位存储的。缓存行是2的整数幂个连续字节,一般为32-256个字节。最常见的缓存行大小是64个字节。当多线程修改互相独立的变量时,如 果这些变量共享同一个缓存行,就会无意中影响彼此的性能,这就是伪共享。缓存行上的写竞争是运行在SMP系统中并行线程实现可伸缩性最重要的限制因素。有 人将伪共享描述成无声的性能杀手,因为从代码中很难看清楚是否会出现伪共享。

为了让可伸缩性与线程数呈线性关系,就必须确保不会有两个线程往同一个变量或缓存行中写。两个线程写同一个变量可以在代码中发现。为了确定互相独立的变量 是否共享了同一个缓存行,就需要了解内存布局,或找个工具告诉我们。Intel VTune就是这样一个分析工具。本文中我将解释Java对象的内存布局以及我们该如何填充缓存行以避免伪共享。

cache-line.png

 

JAVA 6下的方案

解决伪共享的办法是使用缓存行填充,《剖析Disruptor:为什么会这么快?(三)伪共享》提供了缓存行填充的例子:

public final class FalseSharing   implements Runnable {   public final static int NUM_THREADS = 4; // change   public final static long ITERATIONS = 500L * 1000L * 1000L;   private final int arrayIndex;    private static VolatileLong[] longs = new VolatileLong[NUM_THREADS];   static   {     for (int i = 0; i < longs.length; i++)     {       longs[i] = new VolatileLong();     }   }    public FalseSharing(final int arrayIndex)   {     this.arrayIndex = arrayIndex;   }    public static void main(final String[] args) throws Exception   {     final long start = System.nanoTime();     runTest();     System.out.println("duration = " + (System.nanoTime() - start));   }    private static void runTest() throws InterruptedException   {     Thread[] threads = new Thread[NUM_THREADS];      for (int i = 0; i < threads.length; i++)     {       threads[i] = new Thread(new FalseSharing(i));     }      for (Thread t : threads)     {       t.start();     }      for (Thread t : threads)     {       t.join();     }   }    public void run()   {     long i = ITERATIONS + 1;     while (0 != --i)     {       longs[arrayIndex].value = i;     }   }    public final static class VolatileLong   {     public volatile long value = 0L;     public long p1, p2, p3, p4, p5, p6; // comment out   } }

 

VolatileLong通过填充一些无用的字段p1,p2,p3,p4,p5,p6,再考虑到对象头也占用8bit, 刚好把对象占用的内存扩展到刚好占64bit(或者64bit的整数倍)。这样就避免了一个缓存行中加载多个对象。但这个方法现在只能适应JAVA6 及以前的版本了。

 

(注:如果我们的填充使对象size大于64bit,比如多填充16bit – public long p1, p2, p3, p4, p5, p6, p7, p8;。理论上同样应该避免伪共享问题,但事实是这样的话执行速度同样慢几倍,只比没有使用填充好一些而已。还没有理解其原因。所以测试下来,必须是64bit的整数倍)

 

JAVA 7下的方案

上面这个例子在JAVA 7下已经不适用了。因为JAVA 7会优化掉无用的字段,可以参考《False Sharing && Java 7》。

 

因此,JAVA 7下做缓存行填充更麻烦了,需要使用继承的办法来避免填充被优化掉,《False Sharing && Java 7》里的例子我觉得不是很好,于是我自己做了一些优化,使其更通用:

public final class FalseSharing implements Runnable {   public static int NUM_THREADS = 4; // change   public final static long ITERATIONS = 500L * 1000L * 1000L;   private final int arrayIndex;   private static VolatileLong[] longs;    public FalseSharing(final int arrayIndex) {     this.arrayIndex = arrayIndex;   }    public static void main(final String[] args) throws Exception {     Thread.sleep(10000);     System.out.println("starting....");     if (args.length == 1) {       NUM_THREADS = Integer.parseInt(args[0]);     }      longs = new VolatileLong[NUM_THREADS];     for (int i = 0; i < longs.length; i++) {       longs[i] = new VolatileLong();     }     final long start = System.nanoTime();     runTest();     System.out.println("duration = " + (System.nanoTime() - start));   }    private static void runTest() throws InterruptedException {     Thread[] threads = new Thread[NUM_THREADS];     for (int i = 0; i < threads.length; i++) {       threads[i] = new Thread(new FalseSharing(i));     }     for (Thread t : threads) {       t.start();     }     for (Thread t : threads) {       t.join();     }   }    public void run() {     long i = ITERATIONS + 1;     while (0 != --i) {       longs[arrayIndex].value = i;     }   } }

public class VolatileLongPadding {  public volatile long p1, p2, p3, p4, p5, p6; // 注释 }

public class VolatileLong extends VolatileLongPadding {  public volatile long value = 0L; }

 

把padding放在基类里面,可以避免优化。(这好像没有什么道理好讲的,JAVA7的内存优化算法问题,能绕则绕)。不过,这种办法怎么看都有点烦,借用另外一个博主的话:做个java程序员真难。

 

 

JAVA 8下的方案

在JAVA 8中,缓存行填充终于被JAVA原生支持了。JAVA 8中添加了一个@Contended的注解,添加这个的注解,将会在自动进行缓存填充。以上的例子可以改为:

public final class FalseSharing implements Runnable {   public static int NUM_THREADS = 4; // change   public final static long ITERATIONS = 500L * 1000L * 1000L;   private final int arrayIndex;   private static VolatileLong[] longs;    public FalseSharing(final int arrayIndex) {     this.arrayIndex = arrayIndex;   }    public static void main(final String[] args) throws Exception {     Thread.sleep(10000);     System.out.println("starting....");     if (args.length == 1) {       NUM_THREADS = Integer.parseInt(args[0]);     }      longs = new VolatileLong[NUM_THREADS];     for (int i = 0; i < longs.length; i++) {       longs[i] = new VolatileLong();     }     final long start = System.nanoTime();     runTest();     System.out.println("duration = " + (System.nanoTime() - start));   }    private static void runTest() throws InterruptedException {     Thread[] threads = new Thread[NUM_THREADS];     for (int i = 0; i < threads.length; i++) {       threads[i] = new Thread(new FalseSharing(i));     }     for (Thread t : threads) {       t.start();     }     for (Thread t : threads) {       t.join();     }   }    public void run() {     long i = ITERATIONS + 1;     while (0 != --i) {       longs[arrayIndex].value = i;     }   } }

import sun.misc.Contended;@Contendedpublic class VolatileLong {  public volatile long value = 0L; }

 

执行时,必须加上虚拟机参数-XX:-RestrictContended,@Contended注释才会生效。很多文章把这个漏掉了,那样的话实际上就没有起作用。

 

@Contended注释还可以添加在字段上,今后再写文章详细介绍它的用法。

 

参考

http://mechanical-sympathy.blogspot.com/2011/07/false-sharing.html

http://mechanical-sympathy.blogspot.hk/2011/08/false-sharing-java-7.html

http://robsjava.blogspot.com/2014/03/what-is-false-sharing.html