请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”

目录

1. 面试官：“请谈谈你对volatile的理解”

2. 面试官接着问：“既然volatile不能保证原子性，那工作中如何解决这个问题呢？”

3. 官试官：“volatile是如何保证多线程环境下的可见性，JAVA内存模型JMM谈谈你对它的了解”

4. 官试官：“你能编写一个volatile修饰的变量在多线程环境可见性示例不？”

5. 面试官：“为什么volatile不保证原子性呀，你知道底层原理么？”

6. 面试官：“你可以编写一下，volatile不保证原子性的解决示例？”

7. 面试官：volatile能禁止指令重排 ，为什么有指令重排，volatile中怎样做到禁止指令重排？

8. 面试官：你在哪些地方用到过volatile？手写一个Volatile单例

​

1. 面试官：“请谈谈你对volatile的理解”

小李子窃窃私语，这不是正好前段时间复习且项目中使用到的volatile关键字么？于是小李子自信地答道：

volatile是Java虚拟机提供的轻量级的同步机制，volatile 是一个类型修饰符。volatile 的作用是作为指令关键字，确保本条指令不会因编译器的优化而进行指令重排序，同时保证多线程环境下变量值变修改后，其他线程可见性；但volatile不保证原子性哦。使用示例：

volatile int number = 0; // 使用volatile 修饰整型变量number，以保证多线程环境下可见性及禁止指令重排。注：volatile不保证原子性
  • 1.1 保证多线程的可见性
  • 1.2 不保证原子性
  • 1.3 禁止指令重排，一般在单例模式下使用较多

2. 面试官接着问：“既然volatile不能保证原子性，那工作中如何解决这个问题呢？”

小李子心想，还来了个连环炮，好在我有准备。于是比利比利地回答：

工作中，我们有两种方式规避这个问题：

1. 使用JDK提供的 Atomic原子类

比如：AtomicInteger来声明变量，是采用了CAS 比较并交换 compareAndSwapInt，底层调用的是native方法，其意思是通过hotspot底层c/c++方法实现。最终实现是调用了 cmpxchg，cmpxchg指令在多线程下也是有可能被打断，所以在加入lock指令 不允许其他线程访问这块内存区域的数据。

2. 加锁，如synchronized 或 ReentrantLock

3. 官试官：“volatile是如何保证多线程环境下的可见性，JAVA内存模型JMM谈谈你对它的了解”

小李子心底阵阵发凉，前面已经回答的很好，还接着问，有完没完！没办法，回忆一下，继续答道：

Java内存模型（Java Memory Model，简称JMM)  本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范通过规范定制了程序中各个变量(包括实例字段、静态字段和构成数组对象的元素)的访问方式。

JMM关于同步规定:

  1. 线程解锁前，必须把共享变量的值刷新回主内存
  2. 线程加锁前，必须读取主内存的最新值到自己的工作内存
  3. 加锁解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方成为栈空间)，工作内存是每个线程的私有数据区域,而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域,所有线程都可访问，但线程对变量的操作 (读取赋值等) 必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作空间，然后对变量进行操作，操作完成再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存储存着主内存中的变量副本拷贝，因此不同的线程无法访问对方的工作内存，线程间的通讯(传值) 必须通过主内存来完成。 

这样子吧，我画一个JMM内存模型图出来看看就清楚了。JMM内存模型图如下：

4. 官试官：“你能编写一个volatile修饰的变量在多线程环境可见性示例不？”

小李子听到这个就想要骂娘了，还得编一个示例。不过，小Case，小李子接过键盘，啪啦啪啦地敲下代码：

  1. package com.java.meet.c01_11_volatile;
  2.  
  3. import java.time.LocalDateTime;
  4. import java.util.concurrent.TimeUnit;
  5.  
  6. class MyResource {
  7.     //int number = 0; // 此行代码在多线程环境下，变量修改后不可见
  8.     volatile int number = 0; // 此行代码在多线程环境下，变量修改后可见，因为变量被 volatile修饰
  9.  
  10.     public void addT060(){
  11.         this.number = 60;
  12.     }
  13.  
  14. }
  15.  
  16. public class C_02_Volatile_SeeOK {
  17.  
  18.     public static void main(String[] args) { // main是一切方法的运行入口
  19.         seeOkByVolatile();
  20.     }
  21.  
  22.     // volatile 可以保证可见性，及时通知其它线程，主物理内存的值已经被修改。
  23.     // volatile 是通过内存屏障实现
  24.     private static void seeOkByVolatile() {
  25.         MyResource res = new MyResource(); // 资源类
  26.  
  27.         new Thread(() -> {
  28.             System.out.println(LocalDateTime.now() + "\t" + Thread.currentThread().getName() + "线程\t当前值为:" + res.number);
  29.             // 暂停一会儿线程
  30.             try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e){  e.printStackTrace();}
  31.             res.addT060();
  32.             System.out.println(LocalDateTime.now() + "\t" + Thread.currentThread().getName() + "线程\t当前值为:" + res.number);
  33.         }, "AAAA").start();
  34.  
  35.         // 第2个线程就是我们的main线程
  36.         while(res.number == 0){
  37.             // main线程就一直在这里等待循环，走到number值不再等于零
  38.         }
  39.         System.out.println(LocalDateTime.now() + "\t" + Thread.currentThread().getName() + "线程\t当前值为" + res.number);
  40.     }
  41.  
  42. }
  43.

没有被volatile修饰变量，在多线程中被修改值，测试结果如下： 

被volatile修饰变量，在多线程中被修改值，测试结果如下： 

敲出来代码了，哈哈，小李子心里哈哈的暗自高兴~ 

5. 面试官：“为什么volatile不保证原子性呀，你知道底层原理么？”

小李子，捋了下思路，这个So easy嘛。说道：number++在多线程下是非线程安全的。当我们添加volatile 关键字修饰时，n++ 同样被拆分成了3个指令，在多线程环境下，依然不能保证原子性。如下图，是volatile 修饰整型变量n，对n++方法进行反汇编。

  1. package com.java.meet.c01_11_volatile;
  2.  
  3. /**
  4.  * 6_volatile不保证原子理论解释
  5.  *
  6.  * 使用javap -c或javap -verbose
  7.  */
  8.  
  9. public class C_06_T1 {
  10.  
  11.     volatile int n = 0;
  12.  
  13.     /**
  14.      * MyData.java ====> MyData.class ===> 字节码
  15.      * n++ 被拆分成了3个指令
  16.      * 执行getfield拿到原始n；
  17.      * 执行iadd进行加1操作；
  18.      * 执行putfield写把累加后的值写回
  19.      *
  20.      * 查看字节码，需要配置好External tools
  21.      */
  22.  
  23.     /**
  24.     /Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/bin/javap -c com.java.meet.c01_11_volatile.C_06_T1
  25.     Compiled from "C_06_T1.java"
  26.     public class com.java.meet.c01_11_volatile.C_06_T1 {
  27.         volatile int n;
  29.   public com.java.meet.c01_11_volatile.C_06_T1();
  30.         Code:
  31.         0: aload_0
  32.         1: invokespecial #1                  // Method java/lang/Object."":()V
  33.         4: aload_0
  34.         5: iconst_0
  35.         6: putfield      #2                  // Field n:I
  36.         9: return
  38.         public void add();
  39.         Code:
  40.         0: aload_0
  41.         1: dup
  42.         2: getfield      #2                  // Field n:I
  43.         5: iconst_1
  44.         6: iadd
  45.         7: putfield      #2                  // Field n:I
  46.         10: return
  47.     }
  49.     Process finished with exit code 0
  50.     */
  51.     public void add(){
  52.         n++;
  53.     }
  54. }

6. 面试官：“你可以编写一下，volatile不保证原子性的解决示例？”

小李子胸有成竹的说：这样吧，我演示一个volatile修饰的变量在多线程环境下不保证原子性的及其中一个解决volatile不保证原子性办法。其中，可以通过JDK提供的Atomic原子类来保证原子操作，于是，拿起键盘哒哒地敲起来：

  1. package com.java.meet.c01_11_volatile;
  2.  
  3. import java.util.concurrent.atomic.AtomicInteger;
  4.  
  5. class MyNumber {
  6.     volatile int number = 0;
  7.  
  8.     // 请注意，此时number前面是加了volatile关键字修饰的，volatile不保证原子性
  9.     public void addPlusPlus(){
  10.         number++;
  11.     }
  12.  
  13.     // 使用JDK提供的原子类，可以解决volatile不保证原子性问题，采用CAS比较并交换
  14.     AtomicInteger atomicInteger = new AtomicInteger();
  15.     public void addMyAtomic(){
  16.         atomicInteger.getAndIncrement();
  17.     }
  18. }
  19.  
  20. public class C_03_Volatile_NotSupportAtomic {
  21.  
  22.     public static void main(String[] args) { // main是一切方法的运行入口
  23.         notSupportAtomicByVolatile();
  24.     }
  25.  
  26.     // volatile 不保证原子性 及 使用JDK Atomic原子类解决volatile不保证原子性问题
  27.     private static void notSupportAtomicByVolatile() {
  28.         MyNumber res = new MyNumber();
  29.  
  30.         for (int i = 0; i < 20; i++) {
  31.             new Thread(() -> {
  32.                 for (int j = 0; j < 1000; j++) {
  33.                     res.addPlusPlus();
  34.                     res.addMyAtomic();
  35.                 }
  36.             }, String.valueOf(i)).start();
  37.         }
  38.  
  39.         // 需要等待上面20个线程都全部计算完成后，再用main线程取得最终的结果值看是多少？
  40.         while (Thread.activeCount() > 2){
  41.             Thread.yield(); // yield我不执行，让其他的线程更好地执行
  42.         }
  43.  
  44.         System.out.println(Thread.currentThread().getName() + "\t int type,finally number value:" + res.number);
  45.         System.out.println(Thread.currentThread().getName() + "\t AtomicInteger type,finally number value:" + res.atomicInteger);
  46.     }
  47. }

volatile不保证原子性测试结果如下： 

7. 面试官：volatile能禁止指令重排 ，为什么有指令重排，volatile中怎样做到禁止指令重排？

小李子，心里苦呀，我只是想拿月薪30K的薪资，还得挖那么深，没有办法。继续回答：

计算机在执行程序时，为了提高性能，编译器和处理器常常会做指令重排，一把分为以下3种

  1. 编译器优化的重排
  2. 指令并行的重排
  3. 内存系统的重排

单线程环境里面确保程序是最终执行结果和代码顺序执行的结果一致。处理器在进行重新排序是必须要考虑指令之间的数据依赖性。

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程使用的变量能否保持一致性是无法确定的，结果无法预测。

volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。

先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

  1. 一是保证特定操作的执行顺序，
  2. 二是保证某些的内存可见性（利用该特性实现volatile的内存可见性）

由于编译器和处理器都能执行指令重排优化。如果在指令插入一条Memory B 和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

  • 对volatile变量进行写操作时，会在写操作后加入一条store屏障指令，将工作内存中的共享变量值刷新回到主内存
  • 对volatile变量进行读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量

8. 面试官：你在哪些地方用到过volatile？手写一个Volatile单例

小李子喜出望外，这不是送分题。通过DCL双端检查 + Volatile，来实现，卡拉卡拉地写下如下代码：

  1. package com.java.meet.c01_11_volatile;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.HashSet;
  6. import java.util.List;
  7. import java.util.concurrent.TimeUnit;
  8.  
  9. /**
  10.  * 单例模式：volatile版本
  11.  *
  12.  */
  13. public class C_10_SingletonDemo {
  14.  
  15.     /**
  16.      * 多线程环境下，单例模式下，需要DCL机制 + volatile禁止指令重排
  17.      */
  18.     //private static C_10_SingletonDemo instance = null;         // 在非常高的并发情况下，可能获取的对象不是同一个
  19.     private static volatile C_10_SingletonDemo instance = null;   // 在非常高的并发情况下，DCL双端检查 + volatile 可以保证获取的是同一个对象
  20.  
  21.     // 单例类构造方法私有化
  22.     private C_10_SingletonDemo() {
  23.         System.out.println(Thread.currentThread().getName() + "\t我是构造方法SingletonDemo()");
  24.     }
  25.  
  26.     // 如果单纯依靠 DCL (Double Check Lock双端检锁机制)，还是有问题，可能运行1000万次，才出一次问题
  27.     /**
  28.      * DCL(双端检锁) 机制不一定线程安全，原因是有指令重排的存在，加入volatile可以禁止指令重排
  29.      *
  30.      * 原因在于某一个线程在执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化.
  31.      *
  32.      * instance=new SingletonDem(); 可以分为以下步骤(伪代码)
  33.      *
  34.      * memory=allocate(); //1.分配对象内存空间
  35.      *
  36.      * instance(memory);  //2.初始化对象
  37.      *
  38.      * instance=memory;   //3.设置instance的指向刚分配的内存地址,此时instance!=null
  39.      *
  40.      * 步骤2和步骤3不存在数据依赖关系.而且无论重排前还是重排后程序执行的结果在单线程中并没有改变,因此这种重排优化是允许的.
  41.      *
  42.      * memory=allocate();  //1.分配对象内存空间
  43.      *
  44.      * instance=memory;    //3.设置instance的指向刚分配的内存地址,此时instance!=null 但对象还没有初始化完.
  45.      */
  46.     public static C_10_SingletonDemo getInstance(){
  47.         if (instance == null){
  48.             synchronized (C_10_SingletonDemo.class){
  49.                 if (instance == null){
  50.                     instance = new C_10_SingletonDemo();
  51.                 }
  52.             }
  53.         }
  54.  
  55.         if (instance == null) {
  56.             System.out.println("----");
  57.         }
  58.  
  59.         return instance;
  60.     }
  61.  
  62.     // List本身是不安全的, 使用以下才安全
  63.     public static List list = Collections.synchronizedList(new ArrayList());
  64.  
  65.     public static void main(String[] args) throws InterruptedException {
  66.  
  67.         for (int i = 0; i < 30; i++) {
  68.             new Thread(() -> {
  69.                 list.add(C_10_SingletonDemo.getInstance());
  70.             }, String.valueOf(i)).start();
  71.         }
  72.  
  73.         // 等待上述操作完成
  74.         TimeUnit.SECONDS.sleep(2);
  75.  
  76.         boolean oneSingleObject = true;
  77.         for (int i = 0; i < list.size(); i++) {
  78.             for (int j = i+1; j < list.size(); j++) {
  79.                 if (list.get(i) != list.get(j)) {
  80.                     System.out.println("此单例，创建了不同的对象实例！！！\t"  + i + " "+ list.get(i) + "\t" + list.get(j));
  81.                     oneSingleObject = false;
  82.                 }
  83.             }
  84.         }
  85.  
  86.         if (oneSingleObject) {
  87.             System.out.println("通过单例类获取：" + list.size() + " 次依然是同一个对象！");
  88.         }
  89.     }
  90. }

DCL双端检查 + Volatile 单例测试结果如下： 

面试官，看来你对volatile掌握得还不错哈~ 

今天面试，先到这里，回去等通过吧。

文章最后，给大家推荐一些受欢迎的技术博客链接：

  1. JAVA相关的深度技术博客链接
  2. Flinak 相关技术博客链接
  3. Spark 核心技术链接
  4. 设计模式 —— 深度技术博客链接
  5. 机器学习 —— 深度技术博客链接
  6. Hadoop相关技术博客链接
  7. 超全干货--Flink思维导图，花了3周左右编写、校对
  8. 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
  9. 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
  10. 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂
  11. 深入聊聊Java 垃圾回收机制【附原理图及调优方法】

欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

                                           

       

 

注：本文转载自blog.csdn.net的不埋雷的探长的文章"https://blog.csdn.net/weixin_32265569/article/details/107425491"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！