当前位置：网站首页>全面理解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变量被执行指令重排优化.

再来一个例子吧：

static int a = 0,b = 0;
static int x = 0,y = 0;

public static void main(String[] args) throws InterruptedException {

    Thread t1 = new Thread(() -> {
        //读与写的操作主要是看工作内存和主内存之间的交互
        a = 1;  //store写操作，cpu将a赋值为1，然后写到主内存中
        x = b;  //先load,再store，工作内存先从主内存中读取b的值，然后cpu将b值赋值给x，然后再将x写入到主内存
    });

    Thread t2 = new Thread(() -> {
        b = 1;
        y = a;
    });

    t1.start();t2.start();
    t1.join();t2.join();
    System.out.println("x = "+ x + "; y = "+ y + ";");
}

很容易可以想象这个程序输出的是(x=1,y=0)或(x=0,y=1)或(x=1,y=1)，但是在重排序过后，会出现(x=0,y=0) 的情况。是因为t1线程的a = 1和x = b操作之间没有存在数据流的依赖性，因此这两步操作是可以乱序执行，也就是重排序，因此导致了x和y都出现0的情况。如图：

volatile重排序规则表

可以总结为三条：

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