JUC 多线程之 volatile 关键字

一、谈谈你对 volatile 的理解

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

有三个特点：

1. 可以保证可见性
2. 禁止指令重排
3. 不能保证原子性

但是JMM ( java内存模型 )规范必须保证：内存可见性，禁止指令重排（有序性），原子性。

但是volatile关键字不能保证原子性，有可能出现写丢失情况。

二、volatile为什么不能保证原子性

它可以保证修改的值立即能更新到主存，其他线程也会捕捉到被修改后的值，那么为什么不能保证原子性呢？

Java中只有对基本类型变量的赋值和读取是原子操作，如i = 1的赋值操作，但是像j = i或者i++这样的操作都不是原子操作，因为他们都进行了多次原子操作，比如先读取i的值，再将i的值赋值给j，两个原子操作加起来就不是原子操作了。

所以，如果一个变量被volatile修饰了，那么肯定可以保证每次读取这个变量值的时候得到的值是最新的，但是一旦需要对变量进行自增这样的非原子操作，就不会保证这个变量的原子性了。

举个栗子： 一个变量i被volatile修饰，两个线程想对这个变量修改，都对其进行自增操作也就是i++，i++的过程可以分为三步，首先获取i的值，其次对i的值进行加1，最后将得到的新值写会到缓存中。线程A首先得到了i的初始值100，但是还没来得及修改，就阻塞了，这时线程B开始了，它也得到了i的值，由于i的值未被修改，即使是被volatile修饰，主存的变量还没变化，那么线程B得到的值也是100，之后对其进行加1操作，得到101后，将新值写入到缓存中，再刷入主存中。根据可见性的原则，这个主存的值可以被其他线程可见。

问题来了，线程A已经读取到了i的值为100，也就是说读取的这个原子操作已经结束了，只有在做读取操作时，发现自己缓存行无效，才会去读主存的值，所以这个可见性来的有点晚，线程A阻塞结束后，继续将100这个值加1，得到101，再将值写到缓存，最后刷入主存，所以即便是volatile具有可见性，也不能保证对它修饰的变量具有原子性。

三、如何解决不能保证原子性问题

在多线程并发访问下，共享变量使用使用 java.util.concurrent.atomic 包下面的 AtomicInteger 可以保证原子性操作，底层使用CAS算法。

public class Sample {
    //不指定初始值默认为0
    private static AtomicInteger 
    count = new AtomicInteger(0);
    
    public static void increment() {
        //相当于 i++ 操作
        count.getAndIncrement();
    }
}

四、volatile底层的实现机制？

如果把加入volatile关键字的代码和未加入volatile关键字的代码都生成汇编代码，会发现加入volatile关键字的代码会多出一个lock前缀指令。lock前缀指令实际相当于一个内存屏障，内存屏障提供了以下功能：

1. 重排序时不能把后面的指令重排序到内存屏障之前的位置
2. 使得本CPU的Cache写入内存
3. 写入动作也会引起别的CPU或者别的内核无效化其Cache，相当于让新写入的值对别的线程可见。

五、在什么地方用到 volatile

1. 状态量标记：

int a = 0;
volatile bool flag = false;

public void write() {
    a = 2;              //1
    flag = true;        //2
}

public void multiply() {
    if (flag) {         //3
        int ret = a * a;//4
    }
}

这种对变量的读写操作，标记为volatile可以保证修改对线程立刻可见。比synchronized,Lock有一定的效率提升。

2. 单例模式的实现，典型的双重检查锁定（DCL）：

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

这是一种懒汉的单例模式，使用时才创建对象，而且为了避免初始化操作的指令重排序，给instance加上了volatile。