前言：
要真正搞懂volatile的特性需要与JMM对比来看
JMM（线程安全的保证）
JMM：JAVA内存模型（java memory model） 是一种抽象概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（实例字段，静态字段和构成数组对象的元素）的访问方式。
JMM关于同步的规定
- 线程解锁前，必须把共享变量的值刷新回主内存；
- 线程加锁前，必须读取主内存的最新值到自己的工作内存；
- 枷锁解锁是同一把锁。
由于JVM运行程序的实体是线程。而每个线程创建时JVM都会为其创建一个工作内存，工作内存是每个线程的私有数据区域。
JMM中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读写）必须在工作内存中进行。具体步骤：首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存存储着主内存中的变量副本拷贝，因此不同线程间无法访问对方的工作内存，线程的通信必须通过主内存来完成
如图所示 可以说cache缓存 就是 这种JMM内存模型的硬件抽象
JMM的特性：可见性，原子性，有序性。
说回到volatile
volatile
volatile 是java虚拟机提供的轻量级同步机制
导致并发问题的源头是 : 多核 CPU 缓存导致程序的可见性问题、多线程间切换带来的原子性问题以及编译优化带来的顺序性问题。
下面是三个volatile特性
可见性
用代码证明volatile的可见性
class MyDate {
//共享变量 1.1 首先不加volatile关键字
int number = 0;
public void change() {
this.number = 60;
}
}
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.change();
System.out.println(Thread.currentThread().getName() + "\t update number value=" + myDate.number);
}, "A线程").start();
//main线程读到的数据
while (myDate.number == 0) {
//main 线程一直循环等待直到number值不等于0
}
System.out.println(Thread.currentThread().getName() + "\t over number value="+myDate.number);
}
}
首先new了一个名字叫A线程的线程。先让线程sleep三秒钟，此时A线程和main线程都拿到了number的值。然后A线程修改了number的值为60。但是main线程因为没有可见性不知道值发生了修改。还是继续循环等待，证明了此时线程之间没有可见性。
1.2 证明volatile可见性 ，我们在 int number前面加上volatile关键字
volatile int number = 0;
此时main线程由可见性及时知道了主内存中的number值发生了修改，跳出了循环。
不保证原子性
代码证明不保证原子性
class MyDate {
volatile int number = 0;
public void add() {
number++;
}
}
//2.1证明原子性
//原子性是指 完整性，不可分割，就是说某个线程执行时不可分割或被插队。
public class VolatileDemo {
public static void main(String[] args) {
MyDate myDate = new MyDate();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
myDate.add();
}
}, String.valueOf(i)).start();
}
// 等待线程计算完成后 由main线程取最终结果 10*1000 = 1万
while (Thread.activeCount()>2){ //mian线程和GC后台线程
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+"\t sum value="+myDate.number);
}
代码for出10个线程，每个线程做1000次add操作。正常来说10个线程操作完成之后number应该等于10000
但是程序没次运行都会得到不同的结果，而且小于10000.
是由于number++这个操作在java中是线程不安全的。
n++这个操作在字节码中分为了三个步骤
getfield ---- 拿到原始的值n
iadd -------- 进行+1操作
putfield -----把累加后的值写回
当在多线程环境中，如果多个线程都拿到了原始的n，运算完成后在写回数值之前线程被挂起或阻塞，线程恢复后来不及收到可见性通知就向主内存写下了数值，就会发生写覆盖的情况，丢失数据。
导致了在本程序中无法达到10000.
如何解决呢
public synchronized void add() {
number++;
}
首先可能想到的就是synchronized同步方法，但是synchronized太重了，一个方法里面就一个++操作如果用synchronized就好比杀鸡用牛刀，大炮打蚊子。需要功能和性能的同时考虑。
使用java.util.concurrent.atomic下的AtomicInteger类
原子性的增加1 相当于++操作
或者getAndAdd(int delta) 参数填1
//2.3 原子性int
AtomicInteger atomicInteger = new AtomicInteger();
// 原子性方法
public void addWithAtomic(){
atomicInteger.getAndIncrement();
}
至于为什么AtomicInteger能保证原子性，后面有机会继续详解。
禁止指令重排
指令重排：计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，一般分为编译器优化重排，指令并行的重排，内存系统的重排。
在多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程使用的共享变量的一致性时无法保证的。所以结果无法预测。
int a = 0;
boolean flag = false;
public void writer() {
a = 1; //语句1
flag = true; //语句2
}
public void reader() {
if (flag) { //语句3
a = a + 1; //语句4
System.out.println("value:" + a);
}
}
volatile 实现了禁止指令重排序优化，从而避免了多线程环境下程序出现乱序执行的现象
实现：在对volatile变量进行写操作时，会在写操作后面加入一条Memory Barriier（内存屏障）告诉内存和CPU，禁止在内存屏障前后的执行指令重排优化
写
读
volatile 使用场景
DCL（双重检查锁）+ volatile的单例模式
public class Singleton {
private static Singleton instance = null;
// + volatile
private Singleton() {
System.out.println(Thread.currentThread().getName() + "\t Singleton的构造方法");
}
//DCL Double check lock
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
如果不加volatile
由于
instance = new Singleton();
要分为3步骤执行
1.分配对象内存空间
2.初始化对象
3.完成对象的引用
步骤2和步骤3不存在数据依赖关系，所以可能发生重排序，1->3->2 此时的引用对象可能还没有完成初始化
当一条线程访问instance不为null时，由于instance实例还没有初始化完成，就造成了线程安全问题。
