Java程序员面试必备：Volatile全方位解析

1.volatile的用法

	/**
 *  @Author 捡田螺的小男孩
 *  @Date 2020/08/02
 *  @Desc volatile的可见性探索
 */
public class VolatileTest  {

    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();

        Thread t1 = new Thread(task, "线程t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("开始通知线程停止");
                    task.stop = true; //修改stop变量值。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程t2");
        t1.start();  //开启线程t1
        t2.start();  //开启线程t2
        Thread.sleep(1000);
    }
}

class Task implements Runnable {
    boolean stop = false;
    int i = 0;

    @Override
    public void run() {
        long s = System.currentTimeMillis();
        while (!stop) {
            i++;
        }
        System.out.println("线程退出" + (System.currentTimeMillis() - s));
    }
}

	volatile boolean stop = false;

2. vlatile修饰变量的作用

• 保证变量对所有线程可见性;
• 禁止指令重排序
• 不保证原子性

3. 现代计算机的内存模型（计算机模型，MESI协议，嗅探技术，总线）

计算机模型

• 程序执行时，把需要用到的数据，从主内存拷贝一份到高速缓存。
• CPU处理器计算时，从它的高速缓存中读取，把计算完的数据写入高速缓存。
• 当程序运算结束，把高速缓存的数据刷新会主内存。

1、通过在总线加LOCK#锁的方式。 2、通过缓存一致性协议（Cache Coherence Protocol）

总线

总线（Bus）是计算机各种功能部件之间传送信息的公共通信干线，它是由导线组成的传输线束， 按照计算机所传输的信息种类，计算机的总线可以划分为数据总线、地址总线和控制总线，分别用来传输数据、数据地址和控制信号。

MESI协议

当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

嗅探技术

在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据库读到处理器缓存中。

4. Java内存模型（JMM）

• Java虚拟机规范试图定义一种Java内存模型,来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台上都能达到一致的内存访问效果。
• Java内存模型类比于计算机内存模型。
• 为了更好的执行性能，java内存模型并没有限制执行引擎使用处理器的特定寄存器或缓存来和主内存打交道，也没有限制编译器进行调整代码顺序优化。所以Java内存模型会存在缓存一致性问题和指令重排序问题的。
• Java内存模型规定所有的变量都是存在主内存当中（类似于计算机模型中的物理内存），每个线程都有自己的工作内存（类似于计算机模型的高速缓存）。这里的变量包括实例变量和静态变量，但是不包括局部变量，因为局部变量是线程私有的。
• 线程的工作内存保存了被该线程使用的变量的主内存副本，线程对变量的所有操作都必须在工作内存中进行，而不能直接操作操作主内存。并且每个线程不能访问其他线程的工作内存。

	i = i+1;

5.并发编程的3个特性（原子性、可见性、有序性）

原子性

	i =666； // 语句1
i = j;   // 语句2
i = i+1;  //语句 3
i++;   // 语句4
复制代码

• 语句1操作显然是原子性的，将数值666赋值给i，即线程执行这个语句时，直接将数值666写入到工作内存中。
• 语句2操作看起来也是原子性的，但是它实际上涉及两个操作，先去读j的值，再把j的值写入工作内存，两个操作分开都是原子操作，但是合起来就不满足原子性了。
• 语句3读取i的值，加1，再写回主存，这个就不是原子性操作了。
• 语句4 等同于语句3，也是非原子性操作。

可见性

• 可见性就是指当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改。
• Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的，无论是普通变量还是volatile变量都是如此。
• volatile变量，保证新值能立即同步回主内存，以及每次使用前立即从主内存刷新，所以我们说volatile保证了多线程操作变量的可见性。
• synchronized和Lock也能够保证可见性，线程在释放锁之前，会把共享变量值都刷回主存。final也可以实现可见性。

有序性

	double pi  = 3.14;    //A
double r   = 1.0;     //B
double area = pi * r * r; //C

	bool flag = false;
int b = 0;

public void read() {
   b = 1;              //1
   flag = true;        //2
}

public void add() {
   if (flag) {         //3
       int sum =b+b;   //4
       System.out.println("bb sum is"+sum); 
   } 
}

• 程序次序规则：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。
• 管程锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
• volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
• 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作
• 线程终止规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
• 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
• 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始
• 传递性：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

	volatile bool flag = false;
int b = 0;

public void read() {
   b = 1;              //1
   flag = true;        //2
}

public void add() {
   if (flag) {         //3
       int sum =b+b;   //4
       System.out.println("bb sum is"+sum); 
   } 
}

• 首先呢，flag加上volatile关键字，那就禁止了指令重排，也就是1 happens-before 2了
• 根据volatile变量规则，2 happens-before 3
• 由程序次序规则，得出 3 happens-before 4
• 最后由传递性，得出1 happens-before 4，因此妥妥的输出sum=2啦~

6.volatile底层原理

图解volatile是如何保证可见性的？

	flag=true;

DCL单例模式（volatile）&编译对比

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

	0x01a3de0f: mov    $0x3375cdb0,%esi   ;...beb0cd75 33  
                                        ;   {oop('Singleton')}  
0x01a3de14: mov    %eax,0x150(%esi)   ;...89865001 0000  
0x01a3de1a: shr    $0x9,%esi          ;...c1ee09  
0x01a3de1d: movb   $0x0,0x1104800(%esi)  ;...c6860048 100100  
0x01a3de24: lock addl $0x0,(%esp)     ;...f0830424 00  
                                        ;*putstatic instance  
                                        ; - Singleton::getInstance@24

1.重排序时不能把后面的指令重排序到内存屏障之前的位置 2.将本处理器的缓存写入内存 3.如果是写入动作，会导致其他处理器中对应的缓存无效。

内存屏障

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

7.volatile的典型场景

• 1）对变量的写操作不依赖于当前值
• 2）该变量没有包含在具有其他变量的不变式中

7.1 状态标志

	Map configOptions;
char[] configText;
// 此变量必须定义为 volatile
volatile boolean initialized = false;

// 假设以下代码在线程 A 中运行
// 模拟读取配置信息, 当读取完成后将 initialized 设置为 true 以告知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText, configOptions);
initialized = true;
      
// 假设以下代码在线程 B 中运行
// 等待 initialized 为 true, 代表线程 A 已经把配置信息初始化完成
while(!initialized) {
   sleep();
}
// 使用线程 A 中初始化好的配置信息
doSomethingWithConfig();

7.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;
    }
}

8. volatile相关经典面试题

• 谈谈volatile的特性
• volatile的内存语义
• 说说并发编程的3大特性
• 什么是内存可见性，什么是指令重排序？
• volatile是如何解决java并发中可见性的问题
• volatile如何防止指令重排
• volatile可以解决原子性嘛？为什么？
• volatile底层的实现机制
• volatile和synchronized的区别？

8.1 谈谈volatile的特性

8.2 volatile的内存语义

• 当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。
• 当读一个 volatile 变量时，JMM 会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

8.3 说说并发编程的3大特性

• 原子性
• 可见性
• 有序性

8.4 什么是内存可见性，什么是指令重排序？

• 可见性就是指当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改。
• 指令重排是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序。

8.5 volatile是如何解决java并发中可见性的问题

8.6 volatile如何防止指令重排

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

8.7 volatile可以解决原子性嘛？为什么？

	public class Test {
    public volatile int race = 0;
     
    public void increase() {
        race++;
    }
     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<100;j++)
                        test.increase();
                };
            }.start();
        }
        
        //等待所有累加线程结束
        while(Thread.activeCount()>1)  
            Thread.yield();
        System.out.println(test.race);
    }
}

8.8 volatile底层的实现机制

8.9 volatile和synchronized的区别？

• volatile修饰的是变量，synchronized一般修饰代码块或者方法
• volatile保证可见性、禁止指令重排，但是不保证原子性；synchronized可以保证原子性
• volatile不会造成线程阻塞，synchronized可能会造成线程的阻塞，所以后面才有锁优化那么多故事~
• 哈哈，你还有补充嘛~
•