伪共享

例如，CPU 1在读取数据X时，会把相邻的Y也会加载到其缓存行中，此时如果CPU2 需要读取数值Y,也会把相邻的X也加载缓存行中，此时如果CPU1修改数值X时根据缓存一致性协议会导致CPU2中的缓存行失效进而重读，如果CPU2修改数值Y时也会导致CPU1中的缓存行失效重读，这样就导致了CPU间彼此影响导致性能损耗。

一般我们通过缓存行对齐就可以解决这样的问题。

缓存行对齐

基于以上问题的分析，在一些情况下，比如会频繁进行操作的数据，可以根据缓存行的特性进行缓存行对齐（即将要操作的数据凑一个缓存行进行操作）下面使用一个示例进行说明：

package com.example.demo;
 
public class Cacheline_nopadding {
    public static class T{
        //8字节
        private volatile long x = 0L;
    }
    private static T[] arr = new T[2];
 
    static {
        arr[0] = new T();
        arr[1] = new T();
    }
 
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(()->{
            for(long i = 0;i < 1000_0000L;i++){
                //volatile的缓存一致性协议MESI或者锁总线，会消耗时间
                arr[0].x = i;
            }
        });
 
        Thread thread2 = new Thread(()->{
            for(long i = 0;i< 1000_0000L;i++){
                arr[1].x = i;
            }
        });
        long startTime = System.nanoTime();
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("总计消耗时间："+(System.nanoTime()-startTime)/100_000);
    }
}

总计消耗时间：2508

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

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

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

package com.example.demo;
 
public class Cacheline_padding {
    private static class Padding{
        //7*8字节
        public volatile long p1,p2,p3,p4,p5,p6,p7;
    }
    public static class T extends Padding{
        //8字节
        private volatile long x = 0L;
    }
    private static T[] arr = new T[2];
 
    static {
        arr[0] = new T();
        arr[1] = new T();
    }
 
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(()->{
            for(long i = 0;i < 1000_0000L;i++){
                //volatile的缓存一致性协议MESI或者锁总线，会消耗时间
                arr[0].x = i;
            }
        });
 
        Thread thread2 = new Thread(()->{
            for(long i = 0;i< 1000_0000L;i++){
                arr[1].x = i;
            }
        });
        long startTime = System.nanoTime();
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("总计消耗时间："+(System.nanoTime()-startTime)/100_000);
    }
}

总计消耗时间：729

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

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

硬件级别保证有序

乱序问题

CPU为了提高指令的执行效率，比如在执行一条读指令（读取内存的一条数据）时，去执行另一条指令，前提是两条指令间没有依赖关系。

我们来看这样的例子

public class Disorder {
    private static int x = 0, y = 0;
    private static int a = 0, b =0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        for(;;) {
            i++;
            x = 0; y = 0;
            a = 0; b = 0;
            Thread one = new Thread(new Runnable() {
                public void run() {
                    a = 1;
                    x = b;
                }
            });

            Thread other = new Thread(new Runnable() {
                public void run() {
                    b = 1;
                    y = a;
                }
            });
            one.start();other.start();
            one.join();other.join();
            String result = "第" + i + "次 (" + x + "," + y + "）";
            if(x == 0 && y == 0) {
                System.err.println(result);
                break;
            } else {
                //System.out.println(result);
            }
        }
    }


    public static void shortWait(long interval){
        long start = System.nanoTime();
        long end;
        do{
            end = System.nanoTime();
        }while(start + interval >= end);
    }
}

在线程体中未发生乱序问题，那么程序输出的结果就不应该有x=0,y=0的结果，但是根据实际执行情况来看，会输出以下内容

第3932682次 (0,0）

也就是说，是存在乱序问题的。

硬件内存屏障 X86

• sfence:在sfence指令前的写操作当必须在sfence指令后的写操作前完成
• lfence：在lfence指令前的读操作当必须在lfence指令后的读操作前完成
• mfence：在mfence指令前的读写操作当必须在mfence指令后的读写操作前完成

原子指令

如x86上的”lock …” 指令是一个Full Barrier，执行时会锁住内存子系统来确保执行顺序，甚至跨多个CPU。Software Locks通常使用了内存屏障或原子指令来实现变量可见性和保持程序顺序。

JVM级别保证有序性

JVM级别内存屏障

这些都是JVM级别定义的一些规范，具体的实现都是由硬件级别的内存屏障进行保障与支持的。

volatile

volatile用来修饰成员变量（静态变量和实例变量），被修饰的变量在被修改时能够保证每个线程获取该变量的最新值，从而避免出现数据脏读的现象，也就是我们说的保证数据的可见性。volatile可以保证可见性和有序性，但是不能保证原子性。要保证原子需要synchronized和Lock。

字节码级别

字节码级别变化

被volatile修饰的变量在字节码级别的access flags中会多一个volatile字符串

JVM级别

JVM级别

在JVM级别就是根据volatile的写或读操作添加了相应的内存屏障。

StoreStore屏障：禁止上面的普通写和下面的volatile写重排序；

StoreLoad屏障：防止上面的volatile写与下面可能有的volatile读/写重排序

LoadLoad屏障：禁止下面所有的普通读操作和上面的volatile读重排序

LoadStore屏障：禁止下面所有的普通写操作和上面的volatile读重排序

硬件层面

通过相应工具查看汇编指令可以发现，在window上是通过lock指令来实现的。

因此，volatile修饰的变量具有以下的特点：

• Lock前缀的指令会引起处理器缓存写回内存；
• 一个处理器的缓存回写到内存会导致其他处理器的缓存失效；
• 当处理器发现本地缓存失效后，就会从内存中重读该变量数据，即可以获取当前最新值。