volatile：Java内存可见性和指令重排序的轻量级同步-优快云博客

volatile是Java虚拟机提供的一个轻量级同步机制，它有以下两个主要作用，但是需要注意的是，volatile不保证原子性。

保证内存可见性
禁止指令重排序

保证内存可见性

简单来说就是当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值（更新主内存，并通知其他线程）。
Java线程在操作共享资源的时候，不是直接操作内存中的共享变量，而是将变量先拷贝到线程自己的工作空间中，线程使用的时候是操作的自己工作空间的变量，操作完成后，会将修改后的变量在拷贝到主内存，覆盖旧值，但是这个操作对于其他线程不可见。下面举例说明：

public class VolaileDemo {

    private static void testMemoryVisible() {
        MySource mySource = new MySource();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " start");
            try {
                //子线程睡眠3秒，当睡眠结束的时候主线程已经在循环等待状态
                TimeUnit.SECONDS.sleep(3);
                mySource.changeToTen();
                System.out.println(Thread.currentThread().getName() + " change num to " + mySource.num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "ThreadA").start();
        //主线程判断num不等于10就一直循环
        System.out.println(Thread.currentThread().getName() + " start loop");
        while(mySource.num != 10) {
//            System.out.println(); 1
//            try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();} 2
        }
        System.out.println(Thread.currentThread().getName() + " get the new value of num, num = " + mySource.num);
    }

    public static void main(String[] args) {
        testMemoryVisible();
    }
}

class MySource {
    int num = 0;

    public void changeToTen() {
        this.num = 10;
    }
}

上面这段代码最终的输出结果是

main start loop
ThreadA start
ThreadA change num to 10
//代码进入死循环

主线程无法跳出循环，也就是主线程无法得知主内存中的值已经改变。
但是我们将MySource类的成员变量num加上volatile修饰后，就没有这个问题了

volatile int num = 0;

这时候的输出结果是

main start loop
ThreadA start
ThreadA change num to 10
main get the new value of num, num = 10

Process finished with exit code 0

可以看到，主线程拿到了更新后的值，顺利跳出了循环。
另外，这里有个比较让人疑惑的地方，注释1和2，这两个地方只要有一个打开，就算没有volatile关键字修改num，程序也会正常执行结束，这是为什么呢？这里看到了一个大神的文章，讲的很好（膜拜+仰望）：多线程中主存与线程工作空间同步数据的时机
总的来说，主要有以下几个情况会导致线程的工作内存失效，然后必须重新去读取主存的共享变量：

线程中释放锁时
线程切换时
CPU有空闲时间时（比如线程休眠时）

禁止指令重排序

在计算机执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般是以下过程

源代码  --> 编译器优化的重排 --> 指令并行的重排 --> 内存系统的重排 --> 最终执行的指令

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
处理器在进行重排顺序是必须要考虑指令之间的数据依赖性，什么是数据依赖性呢？如

int a = 1;
int x = a;

这段代码中，x依赖于a的值，则此处不能有指令重排

int a = 1;
int x = 2;

这段代码不存在数据依赖，可能存在指令重排，所以执行顺序可能先执行x = 2后执行 a = 1。
所以多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性时无法确定的，结果无法预测
实例：(重排时机不确定，此处不使用代码演示)
首先声明线程共享变量：int a,b,x,y=0

线程1	线程2
x =a（执行结束后，线程切换）	y=b（执行结束后，线程切换）
b=1 （执行结束后，线程切换）	a = 2（执行结束后，线程切换）

以上步骤执行完成后，切换到主线程，此时x=0，y=0

线程1和线程2共享这四个变量。
线程1中，x赋值为a，此时a为0，所以x也为0，然后线程切换。
线程2中，y赋值为b，此时b为0，所以y也为0.
之后对a和b的赋值操作并不会影响到x和y
结果就是x和y都等于0.

如果编译器对这段程序代码执行重排优化后，可能出现如下情况：

线程1	线程2
b=1（执行结束后，线程切换）	a=2 （执行结束后，线程切换）
x=a（执行结束后，线程切换）	y= b（执行结束后，线程切换）

以上步骤执行完成后，切换到主线程，此时x=2，y=1

由于x和b不存在数据依赖，y和a不存在数据依赖，编译器重排后，最终的执行就可能变成以上方式
线程1中，b赋值为1，然后线程切换
线程2中，a赋值为2，然后线程切换
线程1中，x赋值为a，此时a为2，所以x=2，然后线程切换
线程2中，y赋值为b，此时b为1，所以y=1，然后切换到主线程
结果就是x=2，y=1

这个结果说明在多线程环境下，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的。volatile实现禁止指令重排，从而避免了多线程环境下程序出现乱序执行的现象。
大家在使用DCL单例模式的时候，实例使用volatile修饰，目的也就是为了避免指令重排，例如：

public static SingletonDemo getInstance() {
    if (instance == null) {
        synchronized (SingletonDemo.class) {
            if (instance == null) {
                instance = new SingletonDemo();
            }
        }
    }
    return instance;
}

这个地方的instance必须使用volatile修饰，否则这里便有一个很大的隐患，可能会导致拿到的instance是一个未知变量。因为instance = new SingletonDemo();这段代码并不是原子操作，它至少分为以下3个步骤：

给instance对象分配内存空间
调用SingletonDemo类的构造函数等，初始化instance对象
将instance对象指向分配的内存空间，这步一旦执行了，那instance对象就不等于null了

第2步和第3步并步存在数据的依赖关系，所以这里可能发生重排，导致先执行3再执行2，这时候instance并不为null，但是却没有执行初始化instance，如果此时发生了线程切换，此时线程判断instance不为空，就直接返回，导致获取到的instance是半成品，从而导致程序报错。
使用volatile修饰后，程序按照原有顺序执行，那么重排带来的问题也就迎刃而解了。