Java内存模型总结

Java内存模型

内存模型能够理解为在特定的操做协议下，对特定的内存或者高速缓存进行读写访问的过程抽象，不一样架构下的物理机拥有不同的内存模型，Java虚拟机也有本身的内存模型，即Java内存模型（Java Memory Model, JMM）。

在C/C++语言中直接使用物理硬件和操做系统内存模型，致使不一样平台下并发访问出错。而JMM的出现，可以屏蔽掉各类硬件和操做系统的内存访问差别，实现平台一致性，是的Java程序可以“一次编写，处处运行”。

1、主内存和工做内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样底层细节。此处的变量指包括了实例字段、静态字段和构成数组对象的元素，可是不包括局部变量与方法参数，后者是线程私有的，不会被共享。

Java内存模型中规定了全部的变量都存储在主内存中，每条线程还有本身的工做内存（能够与前面讲的处理器的高速缓存类比），线程的工做内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的全部操做（读取、赋值）都必须在工做内存中进行，而不能直接读写主内存中的变量。不一样线程之间没法直接访问对方工做内存中的变量，线程间变量值的传递均须要在主内存来完成。

线程、主内存和工做内存的交互关系以下图所示。

注意：这里的主内存、工做内存与Java内存区域的Java堆、栈、方法区不是同一层次内存划分，这二者基本上没有关系。

2、内存交互操做

由上面的交互关系可知，关于主内存与工做内存之间的具体交互协议，即一个变量如何从主内存拷贝到工做内存、如何从工做内存同步到主内存之间的实现细节，Java内存模型定义了如下八种操做来完成（结合下图）：

·        lock（锁定）：做用于主内存的变量，把一个变量标识为一条线程独占状态。

·        unlock（解锁）：做用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才能够被其余线程锁定。

·        read（读取）：做用于主内存变量，把一个变量值从主内存传输到线程的工做内存中，以便随后的load动做使用

·        load（载入）：做用于工做内存的变量，它把read操做从主内存中获得的变量值放入工做内存的变量副本中。

·        use（使用）：做用于工做内存的变量，把工做内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个须要使用变量的值的字节码指令时将会执行这个操做。

·        assign（赋值）：做用于工做内存的变量，它把一个从执行引擎接收到的值赋值给工做内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操做。

·        store（存储）：做用于工做内存的变量，把工做内存中的一个变量的值传送到主内存中，以便随后的write的操做。

·        write（写入）：做用于主内存的变量，它把store操做从工做内存中一个变量的值传送到主内存的变量中。

 

Java内存模型还规定了在执行上述八种基本操做时，必须知足以下规则：

·        不容许read和load、store和write操做之一单独出现

·        不容许一个线程丢弃它的最近assign的操做，即变量在工做内存中改变了以后必须同步到主内存中。

·        不容许一个线程无缘由地（没有发生过任何assign操做）把数据从工做内存同步回主内存中。

·        一个新的变量只能在主内存中诞生，不容许在工做内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操做以前，必须先执行过了assign和load操做。

·        一个变量在同一时刻只容许一条线程对其进行lock操做，lock和unlock必须成对出现

·        若是对一个变量执行lock操做，将会清空工做内存中此变量的值，在执行引擎使用这个变量前须要从新执行load或assign操做初始化变量的值

·        若是一个变量事先没有被lock操做锁定，则不容许对它执行unlock操做；也不容许去unlock一个被其余线程锁定的变量。

·        对一个变量执行unlock操做以前，必须先把此变量同步到主内存中（执行store和write操做）。

这8种内存访问操做很繁琐，后文会使用一个等效判断原则，即先行发生（happens-before）原则来肯定一个内存访问在并发环境下是否安全。

3、内存模型三大特性

3.1原子性

JMM要求lock、unlock、read、load、assign、use、store、write这8个操做都必须具备原子性，但对于64位的数据类型（long和double，具备非原子协定：容许虚拟机将没有被volatile修饰的64位数据的读写操做划分为2次32位操做进行。（与此相似的是，在栈帧结构的局部变量表中，long和double类型的局部变量可使用2个能存储32位变量的变量槽（Variable Slot）来存储的，

若是多个线程共享一个没有声明为volatile的long或double变量，而且同时读取和修改，某些线程可能会读取到一个既非原值，也不是其余线程修改值的表明了“半个变量”的数值。不过这种状况十分罕见。由于非原子协议换句话说，一样容许long和double的读写操做实现为原子操做，而且目前绝大多数的虚拟机都是这样作的。

3.2可见性

前面分析volatile语义时已经提到，可见性是指当一个线程修改了共享变量的值，其余线程可以当即得知这个修改。JMM在变量修改后将新值同步回主内存，依赖主内存做为媒介，在变量被线程读取前从内存刷新变量新值，保证变量的可见性。普通变量和volatile变量都是如此，只不过volatile的特殊规则保证了这种可见性是当即得知的，而普通变量并不具有这种严格的可见性。除了volatile外，synchronized和final也能保证可见性。

3.3有序性

JMM的有序性表现为：若是在本线程内观察，全部的操做都是有序的；若是在一个线程中观察另外一个线程，全部的操做都是无序的。前半句指“线程内表现为串行的语义”（as-if-serial），后半句指“指令重排序”和普通变量的”工做内存与主内存同步延迟“的现象。

as-if-serial语义(语义)

as-if-serial语义的意思指：管怎么重排序（编译器和处理器为了提升并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵照as-if-serial语义。

as-if-serial语义把单线程程序保护了起来，遵照as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员建立了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担忧重排序会干扰他们，也无需担忧内存可见性问题。

 

重排序

在执行程序时为了提升性能，编译器和处理器常常会对指令进行重排序。从硬件架构上来讲，指令重排序是指CPU采用了容许将多条指令不按照程序规定的顺序，分开发送给各个相应电路单元处理，而不是指令任意重排。重排序分红三种类型：

·        编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，能够从新安排语句的执行顺序。

·        指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。若是不存在数据依赖性，处理器能够改变语句对应机器指令的执行顺序。

·        内存系统的重排序。因为处理器使用缓存和读写缓冲区，这使得加载和存储操做看上去多是在乱序执行。

JMM的重排序屏障

从Java源代码到最终实际执行的指令序列，会通过三种重排序。可是，为了保证内存的可见性，Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。对于编译器的重排序，JMM会根据重排序规则禁止特定类型的编译器重排序；对于处理器重排序，JMM会插入特定类型的内存屏障，经过内存的屏障指令禁止特定类型的处理器重排序。这里讨论JMM对处理器的重排序，为了更深理解JMM对处理器重排序的处理，先来认识一下常见处理器的重排序规则：

其中的N标识处理器不容许两个操做进行重排序，Y表示容许。其中Load-Load表示读-读操做、Load-Store表示读-写操做、Store-Store表示写-写操做、Store-Load表示写-读操做。能够看出：常见处理器对写-读操做都是容许重排序的，而且常见的处理器都不容许对存在数据依赖的操做进行重排序（对应上面数据转换那一列，都是N，因此处理器不容许这种重排序）。

那么这个结论对咱们有什么做用呢？好比第一点：处理器容许写-读操做二者之间的重排序，那么在并发编程中读线程读到多是一个未被初始化或者是一个NULL等，出现不可预知的错误，基于这点，JMM会在适当的位置插入内存屏障指令来禁止特定类型的处理器的重排序。内存屏障指令一共有4类：

·        LoadLoad Barriers：确保Load1数据的装载先于Load2以及全部后续装载指令

·        StoreStoreBarriers：确保Store1的数据对其余处理器可见（会使缓存行无效，并刷新到内存中）先于Store2及全部后续存储指令的装载

·        LoadStoreBarriers：确保Load1数据装载先于Store2及全部后续存储指令刷新到内存

·        StoreLoadBarriers：确保Store1数据对其余处理器可见（刷新到内存，而且其余处理器的缓存行无效）先于Load2及全部后续装载指令的装载。该指令会使得该屏障以前的全部内存访问指令完成以后，才能执行该屏障以后的内存访问指令。

数据依赖性

数据依赖的准肯定义是：若是两个操做同时访问一个变量，其中一个操做是写操做，此时这两个操做就构成了数据依赖。

常见的具备这个特性的如i++、i—。若是改变了具备数据依赖的两个操做的执行顺序，那么最后的执行结果就会被改变。这也是不能进行重排序的缘由。例如：

·        写后读：a = 1; b = a;

·        写后写：a = 1; a = 2;

·        读后写：a = b; b = 1;

重排序遵照数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操做的执行顺序。可是这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操做，不一样处理器之间和不一样线程之间的数据依赖性不被编译器和处理器考虑。

对于final域，编译器和处理器要遵照两个重排序规则。
1）在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用
变量，这两个操做之间不能重排序。
2）初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操做之间不能重排序。

 

4、先行发生原则（happens-before）

 

咱们编写的程序都要通过优化后（编译器和处理器会对咱们的程序进行优化以提升运行效率）才会被运行，优化分为不少种，其中有一种优化叫作重排序，重排序须要遵照happens-before规则，不能说你想怎么排就怎么排，若是那样岂不是乱了套。

 

若是一个操做执行的结果须要对另外一个操做可见，那么这两个操做之间必需要存在happens-before关系。

 

 

happens-before原则定义以下：

1. 若是一个操做happens-before另外一个操做，那么第一个操做的执行结果将对第二个操做可见，并且第一个操做的执行顺序排在第二个操做以前。 
2. 两个操做之间存在happens-before关系，并不意味着必定要按照happens-before原则制定的顺序来执行。若是重排序以后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

 

与程序员密切相关的默认happens-before原则规则以下：

·        程序顺序规则：一个线程中的每一个操做，happens- before 于该线程中的任意后续操做。

·        监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。

·        volatile变量规则：对一个volatile域的写，happens-before 于任意后续对这个volatile域的读。

·        传递性：若是A happens- before B，且B happens-before C，那么A happens- before C。

happen-before原则是JMM中很是重要的原则，它是判断数据是否存在竞争、线程是否安全的主要依据，保证了多线程环境下的可见性。是JMM提供给程序员的代表视图和保证。

 

 

5、解析volatile

 

volatile变量规则

Synchronized是一个比较重量级的操做，对系统的性能有比较大的影响，而volatile是 Java中提供的更轻量级的同步机制，只保证可见性，不能保证原子性。

volatile变量具备2种特性：

·        保证变量的可见性。对一个volatile变量的读，老是能看到（任意线程）对这个volatile变量最后的写入，这个新值对于其余线程来讲是当即可见的。

·        屏蔽指令重排序：指令重排序是编译器和处理器为了高效对程序进行优化的手段，下文有详细的分析。

 

volatile语义并不能保证变量的原子性。对任意单个volatile变量的读/写具备原子性，但相似于i++、i–这种复合操做不具备原子性

只有知足下面2条规则时，才能使用volatile来保证并发安全，不然就须要加锁

·        运算结果不依赖当前变量值，或者只有单一的线程修改变量的值（好比计数器的状况）

·        变量不须要与其余的状态变量共同参与不变约束

如：volatile static int start = 3;

volatile static int end = 6;

线程A执行以下代码：

while (start < end){

//do something

}

线程B执行以下代码：

start+=3;

end+=3;

这种状况下，一旦在线程A的循环中执行了线程B，start有可能先更新成6，形成了一瞬间 start == end，从而跳出while循环的可能性。

 

由于须要在本地代码中插入许多内存屏蔽指令在屏蔽特定条件下的重排序，volatile变量的写操做与读操做相比慢一些，可是其性能开销比锁低不少。

 

 

 

 

原理：

1.      可见性实现：

线程自己并不直接与主内存进行数据的交互，而是经过线程的工做内存来完成相应的操做。这也是致使线程间数据不可见的本质缘由。所以要实现volatile变量的可见性，直接从这方面入手便可。对volatile变量的写操做与普通变量的主要区别有两点：

（1）volatile写的内存语义以下。
当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存

（2）volatile读的内存语义以下。
当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

经过这两个操做，就能够解决volatile变量的可见性问题。

 

2.      有序性实现：

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

 

Volatile语义的加强：

在旧的内存模型中，当A（volatile的操做）和B（非volatile的操做）之间没有数据依赖关系时，A和B之间就可能被重排序。加强后没有数据依赖关系也不能重排。

 

 

参考 

一、http://blog.csdn.net/u011080472/article/details/51337422
二、周志明，深刻理解Java虚拟机：JVM高级特性与最佳实践，机械工业出版社 
三、AlphaWang博客，http://blog.csdn.net/vking_wang/article/details/8574376