Java内存模型

Java内存模型

Java虚拟机规范中试图定义一种Java内存模型(Java Memory Model, JMM)来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。

一.主内存与工作内存

Java内存模型的主要目标是定义程序中变量的访问规则。即在虚拟机中将变量存储到主内存或者将变量从主内存取出这样的底层细节。

注意：这里的变量与Java编程中所说的变量是有所区别的，这里的变量是指实例字段，静态字段和构成数组对象的元素，但不包括局部变量和方法参数，因为后者是线程私有的，不会被共享，不存在竞争问题。

主内存(Main Memory)：此处的主内存与物理硬件的主内存类比，但实际并不是同一个事物，物理硬件的主内存是整个机器的内存，而虚拟机的主内存是虚拟机内存的一部分，Java虚拟机规定所有的变量(实例字段，静态字段和构成数组对象的元素)都存储在主内存中。

工作内存(Working Memory)：每个线程都有自己的工作内存，可与处理器的高速缓存类比，工作内存中保存了该线程使用到的变量的主内存副本拷贝，并且线程对变量的所有操作(Save、Load)都必须在工作内存中进行，而不能直接读写主内存中的变量，不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

主内存、工作内存、线程三者的交互关系如下图所示：

在这里插入图片描述

二.内存间的交互操作

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成，虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用。
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

如果要把一个变量从主内存传输到工作内存，那就要顺序的执行read和load操作，如果要把一个变量从工作内存回写到主内存，就要顺序的执行store和write操作。对于普通变量，虚拟机只是要求顺序的执行，并没有要求连续的执行。也就是说，read和load之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，一种可能出现的顺序是read a、read b、load b、load a。

对于这8中操作，虚拟机也规定了一系列规则，在执行这8中操作的时候必须遵循如下的规则：

不允许read和load、store和write操作之一单独出现，也就是不允许从主内存读取了变量的值但是工作内存不接收的情况，或者不允许从工作内存将变量的值回写到主内存但是主内存不接收的情况。
不允许一个线程丢弃最近的assign操作，也就是不允许线程在自己的工作线程中修改了变量的值却不同步回写到主内存。
不允许一个线程无原因地(没有发生过任何assign操作)把数据从线程的工作内存同步回主内存中。
一个新的变量只能在主内存中"诞生"，不允许在工作内存中直接使用一个未被初始化(load或assign)的变量。即：在执行use、store之前必须对相同的变量执行了load、assign操作。
一个变量在同一时刻只能被一个线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次lock后，需要执行相同次数的unlock操作，变量才会解锁，换句话说就是锁可重入。
对变量执行lock操作，就会清空工作内存中此变量的值，执行引擎使用这个变量之前，需要重新load或者assign操作初始化变量的值。
如果一个变量事先没有被lock操作锁定，那就不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定住的变量。
对一个变量执行unlock之前，必须先把变量同步回主内存中(执行 store 和 write 操作)。

当然，最重要的还是如开始所说，这8个动作必须是原子的，不可分割的。

针对volatile修饰的变量，会有一些特殊规定。

三.volatile变量的特殊规则

关键字 volatile 可以说是 Java 虚拟机中提供的最轻量级的同步机制。Java 内存模型对 volatile 专门定义了一些特殊规则。假定 T 表示一个线程，V 和 W 分别表示两个 volatile 修饰的变量，那么在进行read、load、use、assign、store和write操作的时候需要满足如下规则：

只有当线程T对变量V执行的前一个动作是load，线程T对变量V才能执行use动作；同时只有当线程T对变量V执行的后一个动作是use的时候，线程T对变量V才能执行load操作。所以，线程T对变量V的use动作和线程T对变量V的read、load动作相关联，必须是连续一起出现。也就是在线程T的工作内存中，每次使用变量V之前必须从主内存去重新获取最新的值，用于保证线程T能看得见其他线程对变量V的最新的修改后的值。
只有当线程T对变量V执行的前一个动作是assign的时候，线程T对变量V才能执行store动作；同时只有当线程T对变量V执行的后一个动作是store的时候，线程T对变量V才能执行assign动作。所以，线程T对变量V的assign操作和线程T对变量V的store、write动作相关联，必须一起连续出现。也即是在线程T的工作内存中，每次修改变量V之后必须立刻同步回主内存，用于保证线程T对变量V的修改能立刻被其他线程看到。
假定动作A是线程T对变量V实施的use或assign动作，动作F是和动作A相关联的load或store动作，动作P是和动作F相对应的对变量V的read或write动作；类似的，假定动作B是线程T对变量W实施的use或assign动作，动作G是和动作B相关联的load或store动作，动作Q是和动作G相对应的对变量W的read或write动作。如果动作A先于B，那么P先于Q。也就是说在同一个线程内部，被volatile修饰的变量不会被指令重排序，保证代码的执行顺序和程序的顺序相同。

总结上面三条规则，前面两条可以概括为：volatile类型的变量保证对所有线程的可见性。第三条为：volatile 类型的变量禁止指令重排序优化。

当定义一个 volatile 类型的变量，它将具备两种特性:

第一：是保证此变量对所有线程的可见性，是指当一个线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的，而普通线程不能做到这一点。

注意：虽然 volatile 类型的变量对所有线程都是可见的，但是在各个线程的工作内存中也可以存在不一致的情况，只不过每次使用之前都要先刷新，执行引擎看不到不一致的情况，因此可以认为不存在一致性问题，但是 Java 里面的运算并非原子操作，会导致 volatile 变量的运算在并发场景下一样是不安全的。

第二：禁止指令重排序优化，普通的变量仅仅会保证该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，不能保证变量赋值操作的顺序和程序代码中的执行顺序一致，这也就是 Java 内存模型中描述的“线程内表现为串行的语义”(Within-Thread As-If-Serial Semantics)

四.原子性、可见性与有序性

Java内存模型是围绕着在并发过程中如何处理原子性、可见性和有序性这3个特征来建立的，下面看一下哪些操作实现了这3个特性。

1.原子性(Atomicity)

由Java内存模型来直接保证原子性的变量操作包括read、load、use、assign、store、write，虽然存在long和double的非原子协定，但基本可以忽略不计，目前虚拟机基本都对其实现了原子性。

如果需要更大范围的原子保证，lock 和 unlock 可以满足需求。虽然虚拟机没有把lock和unlock直接开放给用户使用，但却提供了字节码层次的指令 monitorenter 和 monitorexit 来隐式使用这两个操作，对应到 Java 代码就是同步块 synchronized 关键字，因此 synchronized 块之间的代码都具有原子性。

2.可见性(Visibility)

可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。volatile 类型变量特殊规则保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新，是依赖主内存为中介来保证多线程下变量对其他线程的可见性。因此，voliatile 保证了多线程操作时变量的可见性，而普通变量则不能保证这一点。

除了volatile，synchronized 和 final 也可以实现可见性。synchronized 关键字是通过 unlock 之前必须把变量同步回主内存(执行 store、 write 操作)来实现的。final 则是在初始化后就不会更改，只要在初始化过程中没有把 this 的引用传递出去也能保证对其他线程的可见性。

3.有序性(Ordering)

Java 程序中的有序性可以总结为一句话：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行的语义”(Within-Thread As-If-Serial Semantics),后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象。

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 关键字本身就包含了禁止指令重排序的语义，而 synchronized 则是由“一个变量在同一时刻只允许一条线程对其进行 lock 操作”这条规则获得的，这条规则决定了持有同一个锁的两个同步块只能串行地进入。

五.先行发生原则

什么是先行发生原则?

比如说操作 A 先行发生于操作 B，那么在 B 操作发生之前，A 操作产生的“影响”都会被操作 B 感知到。这里的影响是指修改了内存中的共享变量、发送了消息、调用了方法等。

我们来举一个简单的例子说明一下：

// 以下操作在线程 A 中执行
i = 1;

// 以下操作在线程 B 中执行
j = i;

// 以下操作在线程 C 中执行
i = 2;

假设线程 A 中的操作先行发生于线程 B 的操作，那么可以确定线程 B 的操作执行后，变量j的值一定为1，得出这个结论的依据有两个：

1.根据先行发生原则，i = 1 的结果可以被观察到
2.线程 A 操作结束后没有其他线程会修改变量 i 的值

再来考虑线程 C，线程 C 出现在线程 A 和线程 B 的操作之间，继续保持 A 先行发生于 B 的关系，B 和 C 没有先行发生关系，那 j 的值是多少呢？答案是不确定！1 和 2 都有可能，因为线程 C 对变量 i 的影响可能会被线程 B 观察到，也可能不会，此时线程 B 就有读取到过期数据的风险，不具备多线程安全性。

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

1.程序次序原则(Program Order Rule)

在一个线程内部，按照代码的顺序，书写在前面的先行发生与后边的。或者更准确的说是在控制流顺序前面的先行发生与控制流后面的，而不是代码顺序，因为会有分支、跳转、循环等。

2.管程锁定规则(Monitor Lock Rule)

一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须注意的是对同一个锁，后面是指时间上的后面

3.volatile变量规则(Volatile Variable Rule)

对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的后面是指时间上的先后顺序

4.线程启动规则(Thread Start Rule)

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

5.线程终止规则(Thread Termination Rule)

线程中的所有操作都先行发生于对此线程的终止检测，可以通过 Thread.join() 和 Thread.isAlive() 的返回值等手段检测线程是否已经终止执行。

6.线程中断规则(Thread Interruption Rule)

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

7.对象终结规则(Finalizer Rule)

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

8.传递性(Transitivity)

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

引用:

1.《深入理解JAVA虚拟机-第2版》–周志明