简单了解volatile

什么是volatile

volatile是Java的一个关键字，用于修饰变量，保证变量的可见性以及有序性。

volatile的使用场景

线程通信（可见性）

public class volatileTest {

    volatile boolean flag = true;

    @Test
    public void fun() throws InterruptedException {
        // 3s 后修改 flag = false
        interruptFun();

        while (flag) {
            System.out.println("正在循环");
            Thread.sleep(1000);
        }
    }

    private void interruptFun() {
        new Thread(() -> {
            try {
                Thread.sleep(3000);
                flag = false;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();
    }
}

限制指令重排（有序性）

拿懒汉式单例模式来举例，volatile不仅可以保证对象不会被重复创建，同时还可以保证其它线程不会获取到一个未初始化的对象

public class volatileTest {

    volatile Object singleton;

    final Object monitor = new Object();

    @Test
    public void fun() throws InterruptedException {
        Object result = getSingleTon();
    }

    private Object getSingleTon() {

        if (singleton == null) {
            synchronized (monitor) {
                if (singleton == null) {
                    singleton = new Object();
                }
            }
        }
        return singleton;
    }
}

volatile原理

可见性

简而言之就是本线程对共享变量的修改对其它线程是可见的，强制线程每次读本地变量都需要从主存同步最新值，每次修改完之后都需要同步到主存，相当于通过主存通知其它线程把本地变量置为无效状态。

有序性

简而言之就是线程的某个语句的底层指令不会被重排优化（编译器或者处理器优化）而导致最后的语义不同，通过内存屏障来解决这个问题，有4种内存屏障：

• StoreStore：在volatile写之前，保证之前的普通写不会重排到volatile写之后
• StoreLoad：在volatile写之后，保证之后的volatile读/写不会重排volatile写之前
• LoadStore：在volatile读之后，保证之后的普通读不会重排到volatile读之前
• LoadStore：在volatile读之后，保证之后的普通写不会重排到volatile读之前

对于x86处理器，只会重排写-读，不会重排读-读、写-写，所以只需要使用StoreLoad屏障就可以保证有序性。

拿上述的单例模式来说，保证了对volatile的singleton的读取在volatile写之后，就可以保证对象是完全创建好的。