JMM(Java内存模型 Java Memory Model，简称JMM)
JMM(Java内存模型 Java Memory Model，简称JMM)本身是一种抽象的概念并不真实存在，它描述的是一组规则或者规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。
JMM关于同步的规定：
1、线程解锁前，必须把共享变量的值刷新回主内存
2、线程加锁前，必须读取主内存的最新值到自己的工作内存
3、加锁解锁是同一把锁
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下：
例如：将变量age由25修改为37
volatile关键字的作用？
volatile是Java虚拟机提供的轻量级的同步机制。
主要有三大特性：保证可见性、不保证原子性、禁止指令重排。
共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义。
保证不同线程对这个共享变量进行操作时，有可见性，就是其中一个线程对该变量值进行修改，其他线程是马上可见的，volatile关键字会强制将修改的值同步到主内存。
禁止指令重排，禁止编译器优化代码顺序，避免在单例Double Check中导致多次初始化，保证有有序性。
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义： 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
禁止进行指令重排序。
volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量， 只有当前线程可以访问该变量，其他线程被阻塞住。
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。
volatile仅能实现变量的修改可见性，并不能保证原子性；synchronized则可以保证变量的修改可见性和原子性。
volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。
（1）可见性代码验证说明
package com.lc.mono.module.camas.utils.common;
import java.util.concurrent.TimeUnit;
class MyData {
int number = 0;
public void addT060() {
this.number = 60;
}
}
/**
* 验证volatile的可见性
* 假如int number =0;number变量之前根本没有添加volatile关键字修饰
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData(); //资源类
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t come in");
// 暂停一会儿线程
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
myData.addT060();
System.out.println(Thread.currentThread().getName() + "\t update number value: " + myData.number);
}, "AAA").start();
// 第二个线程就是main线程
while (myData.number == 0) {
// main线程就一直等待循环，直到number!=0
}
System.out.println(Thread.currentThread().getName() + "\t mission is over");
}
}输出信息：
AAA线程已经把number由0修改为60，main线程不可见，因此一直等待。
添加volatile关键字
package com.lc.mono.module.camas.utils.common;
import java.util.concurrent.TimeUnit;
class MyData {
volatile int number = 0;
public void addT060() {
this.number = 60;
}
}
/**
* 验证volatile的可见性
* 假如int number =0;number变量之前根本没有添加volatile关键字修饰
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData(); //资源类
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t come in");
// 暂停一会儿线程
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
myData.addT060();
System.out.println(Thread.currentThread().getName() + "\t update number value: " + myData.number);
}, "AAA").start();
// 第二个线程就是main线程
while (myData.number == 0) {
// main线程就一直等待循环，直到number!=0
}
System.out.println(Thread.currentThread().getName() + "\t mission is over main get number value: " + myData.number);
}
}只要有一个修改了主物理内存的值，只要是添加了volatile关键字的变量，其他线程迅速收到最新通知，修改对其他线程可见。
（2）不保证原子性代码验证说明
package com.lc.mono.module.camas.utils.common;
import java.util.concurrent.TimeUnit;
class MyData {
volatile int number = 0;
public void addT060() {
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 是否可以保证原子性？
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
for (int i = 1; i <= 20; i++) {
new Thread(() -> {
for (int j = 1; j <= 1000; j++) {
myData.addPlusPlus();
}
}, String.valueOf(i)).start();
}
// 需要等待上面20个线程全部计算完成之后，再用main线程取得最终的结果值看是多少？
while (Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + "\t finally number value: " + myData.number);
}
}
最终的值应该是20000，但是由于不保证原子性导致数据丢失，导致数据小于20000。
volatile不保证原子性问题解决
加synchronized
使用我们JUC下的AtomicInteger (CAS)
package com.lc.mono.module.camas.utils.common;
import java.util.concurrent.atomic.AtomicInteger;
class MyData {
volatile int number = 0;
public void addT060() {
this.number = 60;
}
public void addPlusPlus() {
number++;
}
AtomicInteger atomicInteger = new AtomicInteger();
public void addMyAtomic() {
atomicInteger.getAndIncrement();
}
}
/**
* 1 验证volatile的可见性
* 1.1 假如int number =0;number变量之前根本没有添加volatile关键字修饰
* 1.2 添加volatile，可以解决可见性问题
* <p>
* 2 验证volatile不保证原子性
* 2.1 原子性指的是什么意思？
* 不可分割、完整性，也即某个线程正在做某个具体业务的时候，中间不可以被加塞或者被分割。需要整体完整
* 要么同时成功，要么同时失败。
* 2.2 volatile不保证原子性案例演示
* 2.3 why
* 2.4 如何解决原子性
* 加synchronized
* 使用我们JUC下的AtomicInteger (CAS)
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
for (int i = 1; i <= 20; i++) {
new Thread(() -> {
for (int j = 1; j <= 1000; j++) {
myData.addPlusPlus();
myData.addMyAtomic();
}
}, String.valueOf(i)).start();
}
// main线程需要等待上面20个线程全部计算完成之后，再用main线程取得最终的结果值看是多少？
while (Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + "\t int type, finally number value: " + myData.number);
System.out.println(Thread.currentThread().getName() + "\t AtomicInteger type, finally number value: " + myData.atomicInteger);
}
}
（3）volatile禁止指令重排
计算机在执行程序的时候，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下3种：
单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
处理器在进行重排序的时候必须要考虑指令之间的数据依赖。
多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
案例一：
public void test() {
int x = 11; //语句1
int y = 12; //语句2
x = x + 5; //语句3
y = x * x; //语句4
}重排的顺序可能是：语句1234、语句2134、语句1324
语句4不可以重排变成第一个，因为处理器在进行重排序的时候必须要考虑指令之间的数据依赖。
案例二：
（1）说明在多线程环境下，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的。
（2）指令重排导致结果输出可能是5或者6
a=1; flag=true;
可能重排为 flag=true; a=1; 导致结果出现5。
总结
volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。
