一、Volate:
1. 请谈谈你对Volate的理解：
1. volate是Java虚拟机提供的轻量级同步机制
三大特性：保证可见性、不保证原子性、禁止指令重排
2. JMM你谈谈：
JMM（Java Memory Model，简称JMM）本身是一种抽象的概念并不真实存在， 他描述的是一组规则或规范，通过这个规范定义了程序中的各个变量（包括实例字段，对象字段和构成数组对象的元素）的访问方式；通过可见性、原子性、有序性来保证线程安全。
JMM关于同步的规定：
1. 线程解锁前，必须把共享变量的值刷回主内存；
2. 线程加锁前，必须读取主内存的最新值到自己的工作内存；
3. 加锁解锁是同一把锁；
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方成为栈空间），工作内存是内个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后将变量写回主内存，不能直接操作主内存中的变量，各个线程的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下图： 硬盘 < 内存 < 缓存 < CPU
《===》 
2.1 可见性：所谓的可见性就是一种及时通知机制
通过前面的JMM介绍，我们知道各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回到主内存中的。
这就可能存在一个线程AA修改了共享变量X的值，但是还未写回到主内存时，另一个线程BB又对主内存中的同一个变量X进行操作，但是此时A线程工作内存中的共享变量X对线程B来说并不可见，这种工作内存与主内存同步延迟现象造成了可见性问题。
代码验证：
package com.example.code.valatile; import java.util.concurrent.TimeUnit; class MyDate { volatile int number = 0 ; public void addTo60() { this.number = 60;} } /** * 1. 验证volatile的可见性 * 1.1 假如int number =0；number之前根本没有添加volatile关键字修饰，没有可见性 */ public class VolatileDemo { public static void main(String[] args) { MyDate myDate = new MyDate(); //资源类，线程操作资源类 new Thread(() -> { System.out.println(Thread.currentThread().getName() + "\t come in"); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } myDate.addTo60(); System.out.println(Thread.currentThread().getName() + "\t Update number value " + myDate.number); },"AAA").start(); while (myDate.number == 0) {} //main线程一直循环，直至number不为空 System.out.println(Thread.currentThread().getName() + "\t mission is over" + myDate.number); } }
2.2 原子性：volatile不保证原子性
number++在多线程下是非线程安全的，如果不加synchronized解决？
* 加synchronized;
* 使用JUC下面的AtomicInteger
代码验证：
package com.example.code.valatile; import java.util.concurrent.TimeUnit; class MyDate { volatile int number = 0 ; public void addTo60() { this.number = 60;} public void addPlusPlus() { number++;} } /** * 1. 验证volatile的可见性 * 1.1 假如int number =0；number之前根本没有添加volatile关键字修饰，没有可见性 * 1.2 添加了Volatile,可以解决可见性问题； * * 2. 验证volatile的原子性： * 2.1 原子性指的是什么意思？ * 不可分割，完整性，及某个线程正在做某个具体业务时，中间不可以被加塞或者分割，需要整体完整，要么同时成功，要么同时失败 * 2.2 volatile不保证原子性的案例演示： * * 2.3 why * * 2.4 如何解决原子性？ * * 加sync * * 使用我们的juc下AtomicInteger */ public class VolatileDemo { public static void main(String[] args) { MyDate myDate = new MyDate(); for (int i = 0; i < 20; i++) { new Thread(()->{ for (int j = 0; j < 1000; j++) { myDate.addPlusPlus(); } },String.valueOf(i)).start(); } while (Thread.activeCount() > 2) { Thread.yield(); } System.out.println(Thread.currentThread().getName() + "\t finally number value:" + myDate.number); } //volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改 private static void seeOkByVolatile() { MyDate myDate = new MyDate(); //资源类，线程操作资源类 new Thread(() -> { System.out.println(Thread.currentThread().getName() + "\t come in"); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } myDate.addTo60(); System.out.println(Thread.currentThread().getName() + "\t Update number value " + myDate.number); },"AAA").start(); while (myDate.number == 0) {} //main线程一直循环，直至number不为空 System.out.println(Thread.currentThread().getName() + "\t mission is over" + myDate.number); } }
2.3 有序性：
计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令进行重排，一般分一下三种：
源代码 ==》 编译器优化重排 ==》 指令并行重排 ==》 内存系统重排 ==》 最终执行指令
单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致；
处理器在进行重排序时必须考虑到指令之间的数据依懒性；
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测；
代码验证：重排1
public void mySort() { int x = 11; //语句1 int y = 12; //语句2 x = x + 5; //语句3 y = x * x; //语句4 } 1234 2134 1324 问题：请问语句4可以重排后变成第一条吗？ 不可以，数据依懒性；
代码验证：重排2
package com.example.code.valatile; public class ReSortSeqDemo { int a = 0 ; boolean flag = false ; public void method01() { a = 1 ; //语句1 flag = true ; //语句2 } //多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测 public void method02() { if (false) { a = a + 5 ; //语句3 System.out.println("***returnVal:" + a); } } }
禁止指令重排小总结：
volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。
先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：
一是保证特定操作的执行顺序；
二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）
由于编译器和处理器都能执行指令重排优化。如果在指令间插入Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障的另外一个作用是强制刷出CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本；
3. 你在那些地方用到过volatile：（单例，读写锁手写缓存，CAS）
3.1 单例模式DCL代码：（Double check Lock 双端检索机制）
package com.example.code.valatile; public class SingletonDemo { private static volatile SingletonDemo instance = null; private SingletonDemo(){ System.out.println("我是构造方法"); } private static SingletonDemo getInstance() { if(instance == null) { synchronized (SingletonDemo.class) { if (instance == null) { instance = new SingletonDemo(); } } } return instance; } public static void main(String[] args) { //单线程 /* System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());*/ //多线程 for (int i = 0; i < 100; i++) { new Thread(() -> {SingletonDemo.getInstance();},String.valueOf(i)).start(); } } }
3.2 单例模式volatile分析：
DCL（双端检锁）不一定线程安全，原因是有指令重排的存在，加入volatile可以禁止指令重排； 原因在于，某一个线程执行到第一次检测，读取到的instance不为null，instance的引用对象可能没有完成初始化。
instance = new SingletonDemo();可以分为以下3部完成（伪代码）
memory = allocate();//1.分配对象内存空间
instance(memory); //2.初始化对象
instance = memory; //3.设置instance指向刚分配的内存地址，此时instance ！=null
步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中没有改变，因此这种重排优化是允许的；
memory = allocate(); //1.分配对象内存空间
instance = memory; //3.设置instance指向刚分配的内存地址，此时instance ！=null，但是对象还没有初始化完成！
instance(memory); //2.初始化对象
但是指令重排只会保证串行语义的一致性（单线程），但不会关心多线程间的语义一致性；
所以但一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全性问题。
原文：https://www.cnblogs.com/luliang888/p/12041712.html