volatile详解

一、作用

1、保证线程可见性

main线程和T线程共享堆内存的数据；main和T也有自己的工作空间，当要访问共享内存的数据flag，会把共享内存的flag复制一份到自己的工作空间中。
例如main线程对flag进行了改变，首先是在自己的空间进行改变，修改后的值会马上修改到共享内存；但是T线程何时检查共享内存的值有没有被改变不好控制。
即 main线程的修改并没有及时的反应到T线程，也就是线程之间不可见。对这个变量加了volatile后，能够保证一个线程对这个变量修改后，另一个线程能够马上知道。
底层是通过CPU的缓存一致性协议（MESI）保证的。

2、禁止指令重排序

指令重排序：CPU原来执行一条指令时，是一步一步的顺序执行；现在的CPU为了提高效率，会并发的执行指令，就是第一个指令执行到一半时，第二个指令可能已经开始执行了，也就是流水线似的执行。这时就要求编译器，要能够对指令重排序产生影响的情况进行相应的处理，此时volatile就派上用场了。

拿DCL单例（Double Check Lock）来解释

public class Singleton {
    private static volatile Singleton INSTANCE;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton.getInstance().hashCode());
            }).start();
        }
    }
    
}

INSTANCE = new Singleton()；（假如里面有个变量int a）new对象的过程分为3步
1）申请内存（赋默认值）；a=0
2）初始化； a=100（假如初始值为100）
3）赋值，把值给变量； 把a的值赋值给INSTANCE，即让INSTANCE指向变量a的地址
如果里面存在指令重排序的话，就存在还未初始化的变量就进行了赋值操作，即2、3两步位置交换了；也就是对象处于半初始化状态就进行了赋值操作。当第一个线程（尽管加了锁），执行到new Singleton()时，new了一半；此时第二个线程来了，首先判断INSTANCE 是否为空，由于INSTANCE已经是半初始化状态，里面已经有值了，不再是空值了，也就是第二个线程已经拿到了这个对象了，这个线程就可以直接使用该对象了，很可能就会使用里面的这个值。本来期望这个值是100，但是这个值却是0，如果这个值是订单数的值这时就存在问题。加了volatile后，对这个对象的指令重排序就不允许存在，即必须是在初始化完成之后才会进行赋值操作。

3、volatile不能保证原子性

public class T {
    public volatile int count = 0;

    public synchronized void m() {
        for (int i = 0; i < 1000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {
        T t = new T();
        List<Thread> threadList = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            threadList.add(new Thread(t::m));
        }

        threadList.forEach((o)->{
            o.start();
        });
        threadList.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }

}

m方法，如果不加synchronized，count始终不会到10000。原因是，当一个线程把count值修改为1后，此时进来了第二、第三个线程，都读到count为1，修改后把count加1（即2）写回去，这时两个线程对count修改后，count的值只从1变到了2，所以最后的结果总是小于10000。归根结底就是count的值是保证了可见性，但是count++本身不是原子性的操作（底层分为几个步骤）。
volatile能保证线程的可见性，但是并不能替代synchronized保证原子性。