JVM缓存行对齐性能优化

缓存行

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

伪共享

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

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

缓存行对齐

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

public class CacheLinePadding {
    private static class Padding {
    	//一个long是8个字节，一共7个long
        //public volatile long p1, p2, p3, p4, p5, p6, p7;
    }

    private static class T extends Padding {
    	//x变量8个字节，加上Padding中的变量，刚好64个字节，独占一个缓存行。
        public volatile long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[0].x = i;
            }
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[1].x = i;
            }
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println((System.nanoTime() - start)  / 100000);
    }
}

上述代码，可以自行测试，当有如下变量时，执行的速度会比没有时更快。

public volatile long p1, p2, p3, p4, p5, p6, p7;

JDK8版本之后，提供了解决伪共享的注解，需要在启动时添加如下配置-XX:-RestrictContended，然后使用sun.misc.Contended注解即可。

public class CacheLinePadding {
	
	@Contended
    private static class T {
        public volatile long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[0].x = i;
            }
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < 10000000; i++) {
                arr[1].x = i;
            }
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println((System.nanoTime() - start)  / 100000);
    }
}