1. volatile特点
volatile的两大特点是可见性和有序性；
volatile的内存语义：
2. 内存屏障(面试重点)
内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求 Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。
内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)。
因此重排序时，不允许把内存屏障之后的指令重排序到内存屏障之前。一句话：对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读，也叫写后读。
volatile凭什么可以保证可见性和有序性：内存屏障 (Memory Barriers / Fences)
2.1 四类内存屏障指令
C++源码分析，IDEA工具里面找Unsafe.class如下：
对应的Unsafe.java如下：
接着，对应的Unsafe.cpp如下：
接着，对应的OrderAccess.hpp如下：
接着，对应的orderAccess_linux_x86.inline.hpp如下：
对应的四条内存屏障指令如下：
屏障类型 | 指令示例 | 说明 |
LoadLoad | Load1;LoadLoad;Load2 | 保证load1的读取操作在load2及后续读取操作之前执行 |
StoreStore | Store1;StoreStore:Store2 | 在store2及其后的写操作执行前，保证store1的写操作已刷新到主内存 |
LoadStore | Load1;LoadStore;Store2 | 在stroe2及其后的写操作执行前，保证load1的读操作已读取结束 |
StoreLoad | Store1;StoreLoad;Load2 | 保证store1的写操作已刷新到主内存之后，load2及其后的读操作才能执行 |
happens-before 之 volatile 变量规则 ：
第一个操作 | 第二个操作：普通读写 | 第二个操作：volatile读 | 第二个操作：volatile写 |
普通读写 | 可以重排 | 可以重排 | 不可以重排 |
volatile读 | 不可以重排 | 不可以重排 | 不可以重排 |
volatile写 | 可以重排 | 不可以重排 | 不可以重排 |
2.1.1 写操作：
2.1.2 读操作：
3. volatile特性
3.1 保证可见性
保证不同线程对这个变量进行操作时的可见性，即变量一旦改变所有线程立即可见。 代码演示如下：
publicclassVolatileSeeDemo
{
staticbooleanflag=true;//不加volatile，没有可见性//static volatile boolean flag = true; //加了volatile，保证可见性publicstaticvoidmain(String[] args)
{
newThread(() -> {
System.out.println(Thread.currentThread().getName()+"\t come in");
while (flag)
{
}
System.out.println(Thread.currentThread().getName()+"\t flag被修改为false,退出.....");
},"t1").start();
//暂停2秒钟后让main线程修改flag值try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
System.out.println("main线程修改完成");
}
}
复制代码
上述代码原理解释如下：线程t1中为何看不到被主线程main修改为false的flag的值？
问题可能:
我们的诉求：
解决： 使用volatile修饰共享变量，就可以达到上面的效果，被volatile修饰的变量有以下特点：
3.1.1 volatile变量的读写过程如下
Java内存模型中定义的8种工作内存与主内存之间的原子操作：
read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)
由于上述只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁，所以，JVM提供了另外两个原子指令：
3.2 没有原子性
volatile变量的复合操作(如i++)不具有原子性，代码演示如下：
classMyNumber{
volatileintnumber=0;
publicvoidaddPlusPlus() {
number++;
}
}
publicclassVolatileNoAtomicDemo {
publicstaticvoidmain(String[] args)throws InterruptedException {
MyNumbermyNumber=newMyNumber();
for (inti=1; i <=10; i++) {
newThread(() -> {
for (intj=1; j <= 1000; j++) {
myNumber.addPlusPlus();
}
},String.valueOf(i)).start();
}
//暂停几秒钟线程try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "\t" + myNumber.number);
}
}
复制代码
3.2.1 从字节码的角度分析上述代码如下：
原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。
publicvoidadd()
{
//不具备原子性，该操作是先读取值，然后写回一个新值，//相当于原来的值加上1，分3步完成
i++;
}
复制代码
如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于add方法必须使用synchronized修饰，以便保证线程安全.
多线程环境下，"数据计算"和"数据赋值"操作可能多次出现，即操作非原子。若数据在加载之后，若主内存count变量发生修改之后，由于线程工作内存中的值在此前已经加载，从而不会对变更操作做出相应变化，即私有内存和公共内存中变量不同步，进而导致数据不一致。
对于volatile变量，JVM只是保证从主内存加载到线程工作内存的值是最新的，也就是数据加载时是最新的。
由此可见volatile解决的是变量读时的可见性问题，但无法保证原子性，对于多线程修改共享变量的场景必须使用加锁同步
3.2.2 读取赋值一个普通变量的情况
当线程1对主内存对象发起read操作到write操作第一套流程的时间里，线程2随时都有可能对这个主内存对象发起第二套操作，如下图所示
既然valatile修饰的变量一修改就是可见，为什么还不能保证原子性？
volatile主要是对其中部分指令做了处理。 要use(使用)一个变量的时候必需load(载入），要载入的时候必需从主内存read(读取）这样就解决了读的可见性。
写操作是把assign和store做了关联(在assign(赋值)后必需store(存储))。store(存储)后write(写入)。也就是做到了给一个变量赋值的时候一串关联指令直接把变量值写到主内存。
就这样通过用的时候直接从主内存取，在赋值到直接写回主内存做到了内存可见性。
3.2.3 读取赋值一个volatile变量的情况
read-load-use 和 assign-store-write 成为了两个不可分割的原子操作， 但是在use和assign之间依然有极小的一段真空期 ，有可能变量会被其他线程读取，导致 写丢失一次
但是无论在哪一个时间点主内存的变量和任一工作内存的变量的值都是相等的。这个特性就导致了volatile变量不适合参与到依赖当前值的运算，如i = i + 1; i++;之类的那么依靠可见性的特点volatile可以用在哪些地方呢？ 通常volatile用做保存某个状态的boolean值or int值。
《深入理解Java虚拟机》提到：
JVM的字节码，i++ 分成三步，间隙期不是原子操作：
3.3 指令禁重排
重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序
重排序的分类和执行流程：
案例 ：不存在数据依赖关系，可以重排序===> 重排序OK 。
存在数据依赖关系，禁止重排序===>重排序发生，会导致程序运行结果不同。
编译器和处理器在重排序时，会遵守数据依赖性，不会改变存在依赖关系的两个操作的执行,但不同处理器和不同线程之间的数据性不会被编译器和处理器考虑，其只会作用于单处理器和单线程环境，下面三种情况，只要重排序两个操作的执行顺序
名称 | 代码示例 | 说明 |
写后读 | a=1;b=a; | 写一个变量之后，再读这个位置 |
写后写 | a=1;a=2; | 写一个变量之后，再写这个变量 |
读后写 | a=b;b=1; | 读一个变量之后，再写这个变量 |
3.3.1 volatile的禁止指令重排底层实现是通过内存屏障。
第一个操作 | 第二个操作：普通读写 | 第二个操作：volatile读 | 第二个操作：volatile写 |
普通读写 | 可以重排 | 可以重排 | 不可以重排 |
volatile读 | 不可以重排 | 不可以重排 | 不可以重排 |
volatile写 | 可以重排 | 不可以重排 | 不可以重排 |
3.3.2 四大屏障的插入情况如下：
代码说明如下：
//模拟一个单线程，什么顺序读？什么顺序写？publicclassVolatileTest {
inti=0;
volatilebooleanflag=false;
publicvoidwrite(){
i = 2;
flag = true;
}
publicvoidread(){
if(flag){
System.out.println("---i = " + i);
}
}
}
复制代码
4. volatile使用
单一赋值可以，but含复合运算赋值不可以(i++之类)，如下：
状态标志，判断业务是否结束，代码演示如下：
/**
* 使用：作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束
* 理由：状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换
* 例子：判断业务是否结束
*/publicclassUseVolatileDemo {
privatevolatilestaticbooleanflag=true;
publicstaticvoidmain(String[] args) {
newThread(() -> {
while(flag) {
//do something......
}
},"t1").start();
//暂停几秒钟线程try {
TimeUnit.SECONDS.sleep(2L);
} catch (InterruptedException e) {
e.printStackTrace();
}
newThread(() -> {
flag = false;
},"t2").start();
}
}
复制代码
对于开销较低的读，写锁策略，代码演示如下：
publicclassUseVolatileDemo {
/**
* 使用：当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销
* 理由：利用volatile保证读取操作的可见性；利用synchronized保证复合操作的原子性
*/publicclassCounter {
privatevolatileint value;
publicintgetValue() {
return value; //利用volatile保证读取操作的可见性
}
publicsynchronizedintincrement() {
return value++; //利用synchronized保证复合操作的原子性
}
}
}
复制代码
DCL双端锁的发布，代码演示如下：
publicclassSafeDoubleCheckSingleton {
privatestatic SafeDoubleCheckSingleton singleton;
//私有化构造方法privateSafeDoubleCheckSingleton() {
}
//双重锁设计publicstatic SafeDoubleCheckSingleton getInstance() {
if (singleton == null) {
//1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象synchronized (SafeDoubleCheckSingleton.class) {
if (singleton == null){
//隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取
singleton = newSafeDoubleCheckSingleton();
}
}
}
//2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象return singleton;
}
}
复制代码
问题：
memory = allocate(); // 1.分配对象的内存空间
ctorInstance(memory); // 2.初始化对象
instance = memory; // 3.设置 instance 指向刚分配的内存地址复制代码
right:
memory = allocate(); // 1.分配对象的内存空间
ctorInstance(memory); // 2.初始化对象
instance = memory; // 3.设置 instance 指向刚分配的内存地址
problem:
memory = allocate(); // 1.分配对象的内存空间
instance = memory; // 3.设置 instance 指向刚分配的内存地址// 注意：此时对象还没有被初始化！！
ctorInstance(memory); // 2.初始化对象复制代码
解决01，代码演示如下：加volatile修饰
publicclassSafeDoubleCheckSingleton {
//通过volatile声明，实现线程安全的延迟初始化。privatevolatilestatic SafeDoubleCheckSingleton singleton;
//私有化构造方法privateSafeDoubleCheckSingleton() {
}
//双重锁设计publicstatic SafeDoubleCheckSingleton getInstance() {
if (singleton == null) {
//1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象synchronized (SafeDoubleCheckSingleton.class){
if (singleton == null) {
//隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取//原理:利用volatile，禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序
singleton = newSafeDoubleCheckSingleton();
}
}
}
//2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象return singleton;
}
}
复制代码
面试题，反周志明老师的案例，你还有不加volatile的方法吗?
解决02：采用静态内部类的方式实现，代码演示如下：
//现在比较好的做法就是采用静态内部内的方式实现publicclassSingletonDemo {
privateSingletonDemo() { }
privatestaticclassSingletonDemoHandler {
privatestaticSingletonDemoinstance=newSingletonDemo();
}
publicstatic SingletonDemo getInstance() {
return SingletonDemoHandler.instance;
}
}
复制代码
5. 小总结
5.1 内存屏障是什么
内存屏障：是一种 屏障指令，它使得 CPU或编译器 对屏障指令的前和后所发出的内存操作 执行一个排序的约束。也叫内存栅栏 或栅栏指令。
5.2 内存屏障能干嘛
5.3 内存屏障四大指令
5.4 面试题：凭什么我们java写了一个volatile关键字 系统底层加入内存屏障？两者关系怎么勾搭上的?
5.5 volatile可见性
volatile 关键字保证可见性，意味着：
对一个volatile修饰的变量进行读操作的话，总是能够读到这个变量的最新的值，也就是这个变量最后被修改的值
一个线程修改了volatile修饰的变量的值的时候，那么这个变量的新的值，会立即刷新回到主内存中
一个线程去读取volatile修饰的变量的值的时候，该变量在工作内存中的数据无效，需要重新到主内存去读取最新的数据
5.6 volatile禁重排
5.7 对比Lock来理解
cpu执行机器码指令的时候，是使用Lock前缀指令来实现volatile的功能的。
Lock指令，相当于内存屏障，功能也类似内存屏障的功能：
加了Lock指令过后的具体表现，就跟JMM添加内存屏障后一样。
5.8 一句话总结
