Java内存模型JMM

一、定义

很多人分不清【java 内存结构】与【java 内存模型】，【java 内存结构】指的是jvm的内存分区，例如：堆、程序计数器、虚拟机栈等这些，【java 内存模型】是 Java Memory Model（JMM）的意思。

简单的说，JMM 定义了一套在多线程读写共享数据时（成员变量、数组）时，对数据的可见性、有序性、和原子性的规则和保障。

二、原子性

　　两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果不一定是0。

例如：对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

　　getstatic i // 获取静态变量i的值

 　　iconst_1 // 准备常量1

 　　iadd // 加法

 　　putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似： 

　　getstatic i // 获取静态变量i的值

　　iconst_1 // 准备常量1

　　isub // 减法

　　putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和线程内存中进行数据交换：

 如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

// 假设i的初始值为0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
getstatic i // 线程1-获取静态变量i的值 线程内i=1
iconst_1 // 线程1-准备常量1
isub // 线程1-自减 线程内i=0
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=0

但多线程下这 8 行代码可能交错运行（为什么会交错？思考一下）： 出现负数的情况：

// 假设i的初始值为0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
getstatic i // 线程2-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
iconst_1 // 线程2-准备常量1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

出现正数的情况：

// 假设i的初始值为0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
getstatic i // 线程2-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
iconst_1 // 线程2-准备常量1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1

解决办法就是加锁，例如：synchronized

三、可见性

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

static boolean run = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
　　while(run){
　　　　// ....
　　}
});
t.start();
Thread.sleep(1000);
run = false; // 线程t不会如预想的停下来
}

为什么呢？分析一下：

1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

 2. 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高 速缓存中，减少对主存中 run 的访问，提高效率

 3. 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读 取这个变量的值，结果永远是旧值

解决办法：volatile（易变关键字）它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到 主存中获取它的值，线程操作 volatile 变量都是直接操作主存，

但是一个线程对 volatile 变量的修改对另一 个线程可见， 不能保证原子性，仅用在一个写线程，多个读线程的情况。

synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是synchronized是属于重量级操作，性能相对更低。

四、有序性

先看一段代码

int num = 0;
boolean ready = false;
// 线程1 执行此方法
public void actor1(I_Result r) {
　　if(ready) {
　　　　r.r1 = num + num;
　　} else {
　　　　r.r1 = 1;
　　}
}
// 线程2 执行此方法
public void actor2(I_Result r) {
　　num = 2;
　　ready = true;
}

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？

如果经过大量测试的话，会发现其中一种结果有可能为0，出现这种现象原因是指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现。

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，例如著名的 double-checked locking 模式实现单例

public final class Singleton {
private Singleton() { }
private static Singleton INSTANCE = null;
public static Singleton getInstance() {
　　// 实例没创建，才会进入内部的 synchronized代码块
　　if (INSTANCE == null) {
　　　　synchronized (Singleton.class) {
　　　　　　// 也许有其它线程已经创建实例，所以再判断一次
　　　　　　if (INSTANCE == null) {
　　　　　　　　INSTANCE = new Singleton();
　　　　　　}
　　　　}
　　}
　　return INSTANCE;
}
}

但在多线程环境下，上面的代码是有问题的， INSTANCE = new Singleton() 对应的字节码为：

0: new #2 // class cn/itcast/jvm/t4/Singleton
3: dup
4: invokespecial #3 // Method "<init>":()V
7: putstatic #4 // Field
INSTANCE:Lcn/itcast/jvm/t4/Singleton;

其中4，7两步的顺序不是固定的，也许 jvm 会优化为：先将引用地址赋值给 INSTANCE 变量后，再执行
构造方法，如果两个线程 t1，t2 按如下时间序列执行：

时间1 t1 线程执行到 INSTANCE = new Singleton();
时间2 t1 线程分配空间，为Singleton对象生成了引用地址（0 处）
时间3 t1 线程将引用地址赋值给 INSTANCE，这时 INSTANCE != null（7 处）
时间4 t2 线程进入getInstance() 方法，发现 INSTANCE != null（synchronized块外），直接
返回 INSTANCE
时间5 t1 线程执行Singleton的构造方法（4 处）

这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将 是一个未初始化完毕的单例

解决办法：对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才 会真正有效

五、happens-before

happens-before 规定了哪些写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结， 抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

1、线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见

static int x;
static Object m = new Object();
new Thread(()->{
　　synchronized(m) {
　　　　x = 10;
　　}
},"t1").start();
new Thread(()->{
　　synchronized(m) {
　　　　System.out.println(x);
　　}
},"t2").start();

2、线程对 volatile 变量的写，对接下来其它线程对该变量的读可见

volatile static int x;
new Thread(()->{
    x = 10;
},"t1").start();
new Thread(()->{
    System.out.println(x);
},"t2").start();

3、线程 start 前对变量的写，对该线程开始后对该变量的读可见

static int x;
x = 10;
new Thread(()->{
    System.out.println(x);
},"t2").start();

4、线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或t1.join()等待它结束）

static int x;
Thread t1 = new Thread(()->{
    x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);

5、线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）

       static int x;
public static void main(String[] args) {
    Thread t2 = new Thread(()->{
        while(true) {
            if(Thread.currentThread().isInterrupted()) {
                System.out.println(x);
                break;
            }
        }
    },"t2");
    t2.start();
    new Thread(()->{
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        x = 10;
        t2.interrupt();
    },"t1").start();
    while(!t2.isInterrupted()) {
        Thread.yield();
    }
    System.out.println(x);
}

对变量默认值（0，false，null）的写，对其它线程对该变量的读可见
具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z

注意：变量都是指成员变量或静态成员变量