1. 面试题一：谈谈 volatile 的使用及其原理

volatile 关键字是用来保证有序性和可见性的。

我们所写的代码，不一定是按照我们自己书写的顺序来执行的，编译器会做重排序，CPU 也会做重排序的，这样做是为了了减少流水线阻塞，提高 CPU 的执行效率。这就需要有一定的顺序和规则来保证，不然程序员自己写的代码都不不知道对不对了，所以有 happens-before 规则。

其中有条就是 volatile 变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作、有序性实现的是通过插入内存屏障来保证的。

被 volatile 修饰的共享变量量，就具有了以下两点特性：

保证了不同线程对该变量操作的内存可见性;
禁止指令重排序。

补充：内存屏障

从 CPU 层面来了解一下什么是内存屏障。

CPU 的乱序执行，本质还是 CPU 多核心、CPU 高速缓存。存在多个缓存的时候，就必须通过缓存一致性协议（MESI）来避免数据不一致的问题，而这个通讯的过程就可能导致乱序访问的问题，也就是运行时的内存乱序访问。

现在的 CPU 架构都提供了内存屏障功能，在 x86 的 CPU 中，实现了相应的内存屏障，写屏障（Store Barrier）、读屏障（Load Barrier）和全屏障（Full Barrier），主要的作用是：

防止指令之间的重排序；
保证数据的可见性。

volatile 的原理

在 JVM 底层 volatile 是采用「内存屏障」来实现的。当我们观察加入 volatile 关键字和没有加入 volatile 关键字时所生成的汇编代码会发现，加入 volatile 关键字时，会多出一个 lock 前缀指令，lock 前缀指令实际上相当于一个内存屏障，内存屏障会提供三个功能：

它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
它会强制将对缓存的修改操作立即写入主存；
如果是写操作，它会导致其他CPU中对应的缓存行无效。

会引发两件事情：

将当前处理器缓存行的数据写回到系统内存；
这个写回内存的操作会使得在其他处理器缓存了该内存地址无效；

什么意思呢？意思就是说当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值，这就保证了可见性。
在这里插入图片描述

2. 面试题二：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 具有可见性，也不能保证对它修饰的变量具有原子性。

测试案例：

/**
 * 实体类，观察num值的可见性，此时没有volatile
 */
class Volatile {
    
    
    // volatile int num = 0; 加上volatile关键字
    int num = 0;  // 不加volatile关键字
    public void addTo60() {
    
    
        this.num = 60;
    }
}

//测试类
public class test {
    
    

    public static void main(String[] args) {
    
    
        //测试可见性
        seeVolatileOk();
    }

    /**
     * aaa线程修改num值为60后，main线程拿到的num=0，死循环。说明线程之间共享变量不可见。
     */
    private static void seeVolatileOk() {
    
    
        Volatile v = new Volatile();
        new Thread(() -> {
    
    
            System.out.println(Thread.currentThread().getName() + "\t come in ");
            try {
    
    
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            v.addTo60();
            System.out.println(Thread.currentThread().getName() + "\t updated num value:" + v.num);

        }, "aaa").start();
        while (v.num==0){
    
    

        }
        System.out.println(Thread.currentThread().getName() + "\t mission is over,updated num value:" + v.num);
    }
}

3. 面试题三：volatile 的内存语义

写内存语义：当写一个 volatile 变量时，JMM 会把该线程本地内存中的共享变量的值刷新到主内存；
读内存语义：当读一个 volatile 变量时，JMM 会把该线程本地内存置为无效，使其从主内存中读取共享变量。

4. 面试题四：volatile 的实现机制

为了实现 volatile 的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。内存屏障插入策略非常保守，但它可以保证在任意处理器平台，任意的程序中都能得到正确的 volatile 内存语义。

在每个volatile写操作的前面插入一个 StoreStore 屏障；
在每个volatile写操作的后面插入一个 StoreLoad 屏障；
在每个volatile读操作的后面插入一个 LoadLoad 屏障；
在每个volatile读操作的后面插入一个 LoadStore 屏障。

5. 面试题五：volatile 与锁的对比

volatile 仅仅保证对单个 volatile 变量的读/写具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码的执行具有原子性。在功能上锁比 volatile 更强大，在可伸缩性和执行性能上 volatile 更有优势。

Java岗面试题--Java并发（volatile 专题）

目录