你必须知道的 volatile 关键字

前言

在高并发实际场景下，volatile 关键字应用较多，同时，这也是面试的必问的一个知识点了。那么，valatile 关键字有什么作用呢？

内存可见性

这需要从 Java 的内存模型（JMM）说起，JMM 规定所有的变量都需要存放在主内存中，同时，每个线程又有着自己的工作内存 (主要做高速缓存)。

这样，线程工作时需要操作变量时，需要将主内存中的数据拷贝到工作内存中。这样线程对数据的任何操作都是基于线程本身的工作内存（目的是为了提升效率），而不能去直接操作主内存以及其他线程的工作内存的数据，当线程对数据做了更新以后，还需要将更新后的数据刷新到主内存中。

以上图为例，在并发情况下，可能会出现线程 B 读取到的数据是线程 A 更新之前的数据，从而导致数据不一致。

这个时候，就需要 volatile 出场了：

当一个变量被 volatile 修饰的时候，任何线程对其做的写操作都会被立即刷新到主内存中，并且强制让那些缓存了该变量的线程内的该变量数据清空，需要从主内存中重新读取最新数据。

注意：volatile 修饰的变量，并不是让线程直接操作主内存获取数据，还是需要将变量拷贝到工作内存中。

volidate 应用 demo

我们模拟一个简单的应用场景，两个线程需要同时访问主内存中的某个标志位变量 flag, 我们用 volidate 来修饰:

public class VolatileRunnable implements Runnable{

    private static volatile boolean flag = true ;

    @Override
    public void run() {
        while (flag) {
            System.out.println(Thread.currentThread().getName()+ "正在运行。。。");
        }
        System.out.println(Thread.currentThread().getName()+ "执行完毕。。。");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileRunable vr = new VolatileRunable();
        new Thread(vr,"thread A").start();

        System.out.println("main 线程正在运行") ;

        TimeUnit.MILLISECONDS.sleep(100) ;

        vr.stopThread();}

    private void stopThread(){
        flag = false ;
    }
}

主线程在对 flag 做了修改以后，flag 会立马被刷新到主内存中，从而及时停止线程 A, 如果说 flag 没有被 volidate 修饰，就可能会出现延迟。

volidate 一定能保证线程的安全性吗？

上面说到的 volidate 能够保证被修改的变量及时被刷新到主内存中，很多人会认为这样就能保证线程的安全性。

答案是否定的。volidate 并不能保证线程的安全性！

public class VolatileInc implements Runnable{

	private static volatile int count = 0 ; // 使用 volatile 修饰基本数据内存不能保证原子性

	//private static AtomicInteger count = new AtomicInteger() ;

	@Override
	public void run() {
		for (int i=0;i<10000 ;i++){
			count ++ ;
			//count.incrementAndGet();}
	}

	public static void main(String[] args) throws InterruptedException {
		VolatileInc volatileInc = new VolatileInc() ;
		Thread t1 = new Thread(volatileInc,"t1") ;
		Thread t2 = new Thread(volatileInc,"t2") ;
		t1.start();
		//t1.join();

		t2.start();
		//t2.join();
		for (int i=0;i<10000 ;i++){
			count ++ ;
			//count.incrementAndGet();}


		System.out.println("最终 Count="+count);
	}
}

上面这段代码中，三个线程对 int i 进行累加，最终的结果都会小于 30000，而不是刚好 30000！

这是什么情况？不是说 volidate 保证了内存的可见性吗？

volidate 固然保证了内存的可见性，使得每个线程都能拿到最新的值，但是 count ++ 这个操作并不是原子的，看似简单的自增加 1 的操作，实际上包含了三个操作：

获取值；
自增；
赋值；

但这三个操作没有原子性，并不能同时完成。

那要如何解决对没有原子性的基本数据的并发安全性呢？

1.用单线程串行执行（不推荐，无法充分发挥多核 CPU 的优势）；
2.通过 synchronize 对数据上锁保证原子性；
3.通过 Atomic 包中的 AtomicInteger 来替换 int, 它的底层利用了 CAS 算法来保证原子性

validate 之指令重排

validate 除了能够保证内存的可见性，它的另一重作用是防止 JVM 进行指令重排优化。

用代码说事：

int a=1 ; // 1
int b=2 ; // 2
int c= a+b ; // 3

上面是一段基础代码，理想情况下它的执行顺序是：1 ==> 2 ==> 3。但是在 JVM 对其进行指令重排优化后，它的执行顺序可能变为： 2 ==> 1 ==> 3.

JVM 的指令重排优化是在保证最终结果不变的情况下进行的。

上面的代码还看不出指令重排对实际业务带来的影响，看下面的代码：

private static Map<String,String> value ;
private static volatile boolean flag = fasle ;

// 以下方法发生在线程 A 中 初始化 Map
public void initMap() {
	// 耗时操作
	value = getMapValue() ; // 1
	flag = true ; // 2
}


// 发生在线程 B 中 等到 Map 初始化成功进行其他操作
public void doSomeThing() {
	while(!flag) {
		sleep();}
	// dosomething
	doSomeThing(value);
}

如果上面的 flag 变量没被 volidate 修饰的话，JVM 指令重排优化后，导致 value 还没有被初始化，就有可能被线程 B 使用了。

这里加上 volidate 之后可以保证业务的正确性。

volidate 防指令重排应用

比较经典的应用场景就是双重懒加载的单例模式了:

public class Singleton {

	private static volatile Singleton singleton;

	private Singleton(){}

	public static Singleton getInstance() {
		if (singleton == null) {
			synchronized (Singleton.class) {
				if (singleton == null) {
					// 防止指令重排
					singleton = new Singleton();}
			}
		}
		return singleton;
	}
}

上面对 Singleton 对象添加 volatile 关键字，就是为了防止指令重排。

如果说我们不使用的话，singleton = new Singleton();，这段代码其实是分为三步：