「github 地址」
1.volatile的用法
volatile关键字是Java虚拟机提供的的「最轻量级的同步机制」，它作为一个修饰符出现，用来「修饰变量」，但是这里不包括局部变量哦。我们来看个demo吧，代码如下:
/**
* @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));
}
}
「运行结果：」可以发现线程t2，虽然把stop设置为true了，但是线程t1对t2的「stop变量视而不可见」，因此，它一直在死循环running中。如果给变量stop加上volatile修饰，线程t1是可以停下来的,运行结果如下：
volatile boolean stop = false;
2. vlatile修饰变量的作用
从以上例子，我们可以发现变量stop，加了vlatile修饰之后，线程t1对stop就可见了。其实，vlatile的作用就是：「保证变量对所有线程可见性」。当然，vlatile还有个作用就是，「禁止指令重排」，但是它「不保证原子性」。
所以当面试官问你「volatile的作用或者特性」，都可以这么回答：
3. 现代计算机的内存模型（计算机模型，MESI协议，嗅探技术，总线）
为了更好理解volatile，先回顾一下计算机的内存模型与JMM（Java内存模型）吧~
计算机模型
计算机执行程序时，指令是由CPU处理器执行的，而打交道的数据是在主内存当中的。
由于计算机的存储设备与处理器的运算速度有几个数量级的差距，总不能每次CPU执行完指令，然后等主内存慢悠悠存取数据吧，所以现代计算机系统加入一层读写速度接近处理器运算速度的高速缓存（Cache），以作为来作为内存与处理器之间的缓冲。
在多路处理器系统中，每个处理器都有自己的高速缓存，而它们共享同一主内存。「计算机抽象内存模型」如下：
随着科学技术的发展，为了效率，高速缓存又衍生出一级缓存（L1），二级缓存（L2），甚至三级缓存(L3);
当多个处理器的运算任务都涉及同一块主内存区域，可能导致「缓存数据不一致」问题。如何解决这个问题呢？有两种方案
总线
CPU和其他功能部件是通过总线通信的，如果在总线加LOCK#锁，那么在锁住总线期间，其他CPU是无法访问内存，这样一来，「效率就比较低了」。
MESI协议
为了解决一致性问题，还可以通过缓存一致性协议。即各个处理器访问缓存时都遵循一些协议，在读写时要根据协议来进行操作，这类协议有MSI、MESI（IllinoisProtocol）、MOSI、Synapse、Firefly及DragonProtocol等。比较著名的就是Intel的MESI（Modified Exclusive Shared Or Invalid）协议，它的核心思想是：
CPU中每个缓存行标记的4种状态（M、E、S、I）,也了解一下吧:
MESI协议是如何实现的？如何保证当前处理器的内部缓存、主内存和其他处理器的缓存数据在总线上保持一致的？「多处理器总线嗅探」
嗅探技术
4. Java内存模型（JMM）
举个例子吧，假设i的初始值是0，执行以下语句：
i = i+1;
首先，执行线程t1从主内存中读取到i=0，到工作内存。然后在工作内存中，赋值i+1,工作内存就得到i=1，最后把结果写回主内存。因此，如果是单线程的话，该语句执行是没问题的。但是呢，线程t2的本地工作内存还没过期，那么它读到的数据就是脏数据了。如图：
Java内存模型是围绕着如何在并发过程中如何处理「原子性、可见性和有序性」这3个特征来建立的，我们再来一起回顾一下~
5.并发编程的3个特性（原子性、可见性、有序性）
原子性
原子性，指操作是不可中断的，要么执行完成，要么不执行，基本数据类型的访问和读写都是具有原子性，当然（long和double的非原子性协定除外）。我们来看几个小例子：
i =666； // 语句1
i = j; // 语句2
i = i+1; //语句 3
i++; // 语句4
可见性
有序性
Java虚拟机这样描述Java程序的有序性的：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中，观察另一个线程，所有的操作都是无序的。
后半句意思就是，在Java内存模型中，「允许编译器和处理器对指令进行重排序」，会影响到多线程并发执行的正确性；前半句意思就是「as-if-serial」的语义，即不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不会被改变。
比如以下程序代码：
double pi = 3.14; //A
double r = 1.0; //B
double area = pi * r * r; //C
步骤C依赖于步骤A和B，因为指令重排的存在，程序执行顺讯可能是A->B->C,也可能是B->A->C,但是C不能在A或者B前面执行，这将违反as-if-serial语义。
看段代码吧，假设程序先执行read方法，再执行add方法，结果一定是输出sum=2嘛？
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);
}
}
如果是单线程，结果应该没问题，如果是多线程，线程t1对步骤1和2进行了「指令重排序」呢？结果sum就不是2了，而是0，如下图所示：
这是为啥呢？「指令重排序」了解一下，指令重排是指在程序执行过程中,「为了提高性能」, 「编译器和CPU可能会对指令进行重新排序」。CPU重排序包括指令并行重排序和内存系统重排序，重排序类型和重排序执行过程如下：
实际上，可以给flag加上volatile关键字，来保证有序性。当然，也可以通过synchronized和Lock来保证有序性。synchronized和Lock保证某一时刻是只有一个线程执行同步代码，相当于是让线程顺序执行程序代码了，自然就保证了有序性。
实际上Java内存模型的有序性并不是仅靠volatile、synchronized和Lock来保证有序性的。这是因为Java语言中，有一个先行发生原则（happens-before）：
根据happens-before的八大规则，我们回到刚的例子，一起分析一下。给flag加上volatile关键字，look look它是如何保证有序性的，
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);
}
}
6.volatile底层原理
以上讨论学习，我们知道volatile的语义就是保证变量对所有线程可见性以及禁止指令重排优化。那么，它的底层是如何保证可见性和禁止指令重排的呢？
图解volatile是如何保证可见性的？
在这里，先看几个图吧，哈哈~
假设flag变量的初始值false，现在有两条线程t1和t2要访问它，就可以简化为以下图：
如果线程t1执行以下代码语句，并且flag没有volatile修饰的话；t1刚修改完flag的值，还没来得及刷新到主内存，t2又跑过来读取了，很容易就数据flag不一致了，如下：
flag=true;
如果flag变量是由volatile修饰的话，就不一样了，如果线程t1修改了flag值，volatile能保证修饰的flag变量后，可以「立即同步回主内存」。如图：
细心的朋友会发现，线程t2不还是flag旧的值吗，这不还有问题嘛？其实volatile还有一个保证，就是「每次使用前立即先从主内存刷新最新的值」，线程t1修改完后，线程t2的变量副本会过期了，如图：
显然，这里还不是底层，实际上volatile保证可见性和禁止指令重排都跟「内存屏障」有关，我们编译volatile相关代码看看~
DCL单例模式（volatile）&编译对比
DCL单例模式（Double Check Lock，双重检查锁）比较常用，它是需要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;
}
}
编译这段代码后，观察有volatile关键字和没有volatile关键字时的instance所生成的汇编代码发现，有volatile关键字修饰时，会多出一个lock addl $0x0,(%esp)，即多出一个lock前缀指令
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
lock指令相当于一个「内存屏障」，它保证以下这几点：
显然，第2、3点不就是volatile保证可见性的体现嘛，第1点就是禁止指令重排列的体现。
内存屏障
内存屏障四大分类：（Load 代表读取指令，Store代表写入指令）
为了实现volatile的内存语义，Java内存模型采取以下的保守策略
有些小伙伴，可能对这个还是有点疑惑，内存屏障这玩意太抽象了。我们照着代码看下吧：
内存屏障保证前面的指令先执行，所以这就保证了禁止了指令重排啦，同时内存屏障保证缓存写入内存和其他处理器缓存失效，这也就保证了可见性，哈哈~
7.volatile的典型场景
通常来说，使用volatile必须具备以下2个条件：
实际上，volatile场景一般就是「状态标志」，以及「DCL单例模式」。
7.1 状态标志
深入理解Java虚拟机，书中的例子：
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相关经典面试题
8.1 谈谈volatile的特性
8.2 volatile的内存语义
8.3 说说并发编程的3大特性
8.4 什么是内存可见性，什么是指令重排序？
8.5 volatile是如何解决java并发中可见性的问题
底层是通过内存屏障实现的哦，volatile能保证修饰的变量后，可以立即同步回主内存，每次使用前立即先从主内存刷新最新的值。
8.6 volatile如何防止指令重排
也是内存屏障哦，跟面试官讲下Java内存的保守策略：
再讲下volatile的语义哦，重排序时不能把内存屏障后面的指令重排序到内存屏障之前的位置
8.7 volatile可以解决原子性嘛？为什么？
不可以，可以直接举i++那个例子，原子性需要synchronzied或者lock保证
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底层的实现机制
可以看本文的第六小节，volatile底层原理哈，主要你要跟面试官讲述，volatile如何保证可见性和禁止指令重排，需要讲到内存屏障~
8.9 volatile和synchronized的区别？
推荐之前写的一篇文章：Synchronized解析——如果你愿意一层一层剥开我的心