Java 内存模型&先行发生原则

1. Java 内存模型

Java 内存模型（JMM Java Memory Model )，试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。

处理器上寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。

加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。

2. 主内存与工作内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。

JMM规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory），线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。

3. 内存间交互操作

Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作，这八个操作都具有原子性。

• read(读取)：作用于主内存的变量，把一个变量的值从主内存传输到工作内存中。
• load(载入)：作用于工作内存的变量，把 read 得到的值放入工作内存的变量副本中。
• use(使用)：作用于工作内存的变量，把工作内存中一个变量的值传递给执行引擎。
• assign(赋值)：作用于工作内存的变量，把一个从执行引擎接收到的值赋给工作内存的变量。
• store(存储)：作用于工作内存的变量，把工作内存的一个变量的值传送到主内存中。
• write(写入)：作用于主内存的变量，把 store 得到的值放入主内存的变量中。
• lock(锁定)：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
• unlock(解锁)：作用于主内存的变量，它取消变量标识为一条线程独占的状态。

4. 内存模型三大特性

原子性

Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性(但商业虚拟机一般都把64位数据实现为具有原子性)。

更大范围的原子性，可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。

可见性

可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。

主要有有三种实现可见性的方式：

• volatile
• synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
• final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。

有序性

有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。

也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。

5. 先行发生原则 (happens-before)

上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成，但只保证顺序不保证连续。

下面是Java 内存模型下一些“天然的”先行发生关系，这些先行发生关系无需任何同步器协助就已经存在，如果两个操作之间的关系不在此列，并且无法从下列规则推导出来的话，它们就没有顺序保障，虚拟机可以对它们随意进行重排序（但符合线程内串行）。

5.1 程序次序规则 (Program Order Rule) / 单一线程原则 (single Thread rule)

在一个线程内，在程序前面的操作先行发生于后面的操作。

5.2 管程锁定规则 (Monitor Lock Rule)

一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。

5.3 volatile 变量规则 (Volatile Variable Rule)

对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。

5.4 线程启动规则 (Thread Start Rule)

Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。

5.5 线程终止规则 (Thread Termination Rule)

线程中的所有操作都先行发生于对此线程的终止检测，可以通过 Thread.join() 方法结束、 Thread.isAlive() 的返回值检测线程是否已经终止。

5.6 线程中断规则 (Thread Interruption Rule)

对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。

5.7 对象终结规则 (Finalizer Rule)

一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。

5.8 传递性 (Transitivity)

如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。

先行发生原则举例：

假设存在线程A和线程B，线程A先（时间上的先后）调用了setValue(1) ，然后线程B调用了同一个对象的 getValue() ，那么线程B收到的返回值是什么？

private int value = 0;
public void setValue(int value) {
    this.value = value;
}
public int getValue() {
    return value;
}

答案是不一定。因为这里不符合先行发生原则的各项规则。
怎么修复呢？

• 可以把两个方法都定位为 synchronized 方法，这样可以套用管程锁定规则。
• 可以把value定位为 volatile 变量，可以套用volatile 变量规则（这里的setValue方法不依赖value的当前值）。