理解Volatile关键字，其实看这一篇就够了，写的非常细致

前言

volatile是Java虚拟机提供的轻量级的同步机制。

volatile关键字作用是什么？

两个作用：

1.保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。

2.禁止指令重排序优化。

volatile的可见性

关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总数立即可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中；

下面来测试一下，此时的还未initFlag被volatile修饰。

private boolean initFlag = false;
 
public void test() throws InterruptedException{
    Thread threadA = new Thread(() -> {
        while (!initFlag) {
 
        }
        String threadName = Thread.currentThread().getName();
        System.out.println("线程" + threadName+"获取到了initFlag改变后的值");
    }, "threadA");
 
    //线程B更新全局变量initFlag的值
    Thread threadB = new Thread(() -> {
        initFlag = true;
    }, "threadB");
    
    //确保线程A先执行
    threadA.start();
    Thread.sleep(2000);
    threadB.start();
}

执行结果：控制台只打印了 "线程threadB改变了initFlag的值"，且程序并未终止。

此时initFlag已经被volatile关键字修饰了

private volatile boolean initFlag = false;
 
public void test() throws InterruptedException{
    Thread threadA = new Thread(() -> {
        while (!initFlag) {
 
        }
        String threadName = Thread.currentThread().getName();
        System.out.println("线程" + threadName+"获取到了initFlag改变后的值");
    }, "threadA");
 
    Thread threadB = new Thread(() -> {
        initFlag = true;
        String threadName = Thread.currentThread().getName();
        System.out.println("线程" + threadName+"改变了initFlag的值");
    }, "threadB");
 
    //确保线程A先执行
    threadA.start();
    Thread.sleep(2000);
    threadB.start();
}

执行结果：

线程threadB改变了initFlag的值
线程threadA获取到了initFlag改变后的值

并且程序已经结束了。

这个案例充分说明了volatile的可见性作用。

volatile无法保证原子性

来个案例说明一切：

private static volatile int count = 0;
/**
 * count虽然被volatile关键字修饰，但是结果并不是50000，而是小于等于50000
 **/
public static void main(String[] args) throws InterruptedException{
 
    //开启10个线程，分别对count进行自增操作
    for (int i = 0; i < 10; i++) {
        Thread thread = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                count++;    //先读，再加，不是一个原子操作
            }
        });
        thread.start();
    }
    Thread.sleep(2000);
    
    System.out.println("count==" + count);
}

count虽然被volatile关键字修饰了，但是输出的结果会小于等于50000，足以说明了volatile无法保证原子性。

volatile禁止重排优化

volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。

内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执行顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉

编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

总之，volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化。

下面看一个非常典型的禁止重排优化的例子，如下：

//禁止指令重排优化
private volatile static VolatileSingleton singleton;
 
public static VolatileSingleton getInstance(){
    if(singleton != null){
        synchronized (VolatileSingleton.class){
            if(singleton != null){
                //多线程环境下可能会出现问题的地方
                singleton = new VolatileSingleton();
            }
        }
    }
    return singleton;
}

新new一个对象是分为三步来完成：

memory = allocate();//1.分配对象内存空间

instance(memory);//2.初始化对象

singleton = memory;//3.设置singleton对象指向刚分配的内存地址，此时singleton != null

由于步骤1和步骤2间可能会重排序，如下：

memory = allocate();//1.分配对象内存空间

singleton = memory;//3.设置singleton对象指向刚分配的内存地址，此时singleton != null

instance(memory);//2.初始化对象

由于步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果,在单线程中并没有改变，因此这种重排优化是允许的。但是指令重排只会保证串行语义的执行的一致性(单线程)，但并不会关心多线程间的语义一致性。所以当一条线程访问singleton不为null时，由于singleton实例未必已初始化完成，也就造成了线程安全问题,volatile禁止singleton变量被执行指令重排优化.

volatile重排序规则表

可以总结为三条：

1. 当第二个操作是volatile 写时，不管第一个操作是什么，都不能重排序。这个规则确保volatile 写之前的操作不会被编译器重排序到volatile 写之后。
2. 当第一个操作是volatile 读时，不管第二个操作是什么，都不能重排序。这个规则确保volatile 读之后的操作不会被编译器重排序到volatile 读之前。
3. 当第一个操作是volatile 写，第二个操作是volatile 读时，不能重排序。

最后

感谢你看到这里，看完有什么的不懂的可以在评论区问我，觉得文章对你有帮助的话记得给我点个赞，每天都会分享java相关技术文章或行业资讯，欢迎大家关注和转发文章！