Java内存模型学习笔记（一）—

1、并发编程模型的分类

在并发编程中，我们需要处理两个关键的问题：1、线程间如何通信，2、线程间如何同步。通信是指线程之间以何种机制来交换信息，同步是指程序用于不同线程之间操作发生相对顺序的机制。

在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。在共享内存的并发模型中，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来进行隐式的进行通信。在消息传递的并发模型中，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式的进行通信。

在共享内存并发模型里，同步是显式进行的，因为程序员必须显式地指定某种方式或者编写某段代码需要线程之间互斥执行。在消息传递的并发模型里，由于消息发送必须在消息的接收之前，因此同步是隐式进行的。

java的并发采用的是共享内存模型，java线程之间的通信总是隐式进行的，整个通信过程对程序员完全透明，如果程序员不理解隐式进行的线程之间通信的工作机制，那么将会遇到各种莫名其妙的内存可见性问题。

2、JMM——java内存模型

在java中，所有的实例域、静态域和数组元素都存储在堆内存中，堆内存是线程之间共享的区域。局部变量、方法定义的参数和异常处理参数不会在线程之间共享，它们不会有内存可见性问题，也不受到内存模型的制约与影响。

java线程之间的通信由JMM(java内存模型)控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系（高能预警！！）：线程之间共享的变量存储在主内存（main memory）中，每一个线程都有一个私有的本地内存（local memory）,本地内存中存储的是该线程对共享变量的拷贝副本。注意：本地内存是JMM的一个抽象概念，并不真实存在。java内存模型的抽象示意图如下：

从图上来看，线程A和线程B之间要通信的话，必须经历下面两个步骤：

首先，线程A将本地内存中更新过的共享变量刷新到主内存中；
然后，线程B到主内存中读取共享变量（注意，此时的共享变量是被A更新过的）。

JMM模型两条规定：

线程对共享变量的所有操作必须在自己的内存中进行，不能直接从主内存中读写；
不同线程之间无法直接访问其它线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

来一个示意图说明一下这件事：

如图所示，线程A和线程B的都将主内存中共享变量X拷贝到自己的工作内存中。假设，初始值是 x = 0。线程A在自己的本地内存中将 x 的值改为了1，然后将这个修改过的x 刷写到主内存中。线程B到主内存中读取线程A修改过的值，此时，线程B的本地内存中的x的值也变成了1。这样，线程A和线程B就完成了一次通信。

回顾一下整个过程，从整体看来，这两个步骤实质上是线程A在给线程B发消息，而这个过程必须依赖于主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来提供内存可见性（一个线程对共享变量值的修改，能够及时地被其它线程看到）。

因此，要实现共享变量的可见性，必须保证两点：

线程修改后的共享变量值能够及时从工作内存刷新到主内存中；
其他线程能够及时的把共享变量的最新值从主内存更新到自己的工作内存中。

在Java语言层面支持的可见性实现原理方式有Synchronize和Volatile。

3、指令重排

在执行一段程序的时候，为了性能，编译器和处理器常常会对一些指令进行重排。重排序分为三种类型：

编译器优化的重排序：编译器在不改变单线程语义的前提下，可以重新安排语句的执行顺序。
指令级并行的重排序：现代处理器采用了指令级并行技术来将多条指令重叠执行（计算机组成原理的课程中有讲到）。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序：由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从java源码到最终实际执行的指令序列，分别会经历下面三种重排序：

这些重排序可能导致多线程程序出现内存可见性问题。对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排都禁止）。对于处理器排序，JMM的处理器重排序规则会要求java编译器在生成指令序列时，插入特定类型的内存屏障（memory barriers，intel称之为memory fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是禁止所有的处理器重排序）。

JMM属于语言级的内存模型，它确保不同的编译器和不同的处理器平台之上，通过禁止特定类型的编译器重排序和处理器重排序指令，为程序提供一致的内存可见性保证。

4、处理器重排序与内存屏障指令

现代的处理器使用写缓冲区来临时保存向内存中写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免处理器停顿下来等待向内存中写入数据而产生的延迟。同时，通过批处理的方式刷新写缓冲区，以及合并写缓冲区对同一内存地址的多次写，可以减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行顺序，不一定与内存实际发生的读/写操作顺序一致！为了具体说明，请看下面示例：

Processor A	Processor B
a = 1; //A1	b = 2; //B1
x = b; //A2	y = a; //B2

初始状态：a = b = 0 ，处理器允许执行后得到结果：x = y = 0

这里处理器A和处理器B可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。当以这种时序执行时，程序就可以得到x = y = 0的结果。

从内存操作实际发生顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真执行了。虽然处理器A执行内存操作的顺序为：A1->A2，但内存操作实际发生的顺序却是：A2->A1。此时，处理器A的内存操作顺序被重排序了（处理器B的情况和处理器A一样）。

这里的关键是，由于写缓冲区仅对自己的处理器可见，它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区，因此现代的处理器都会允许对写-读操作重排序。

为了保证内存可见性，java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。JMM把内存屏障指令分为下列四类：

屏障类型	指令示例	说明
LoadLoadBarriers	Load1; LoadLoad; Load2	确保Load1数据的装载，之前于Load2及所有后续装载指令的装载。
StoreStoreBarriers	Store1; StoreStore; Store2	确保Store1数据对其他处理器可见（刷新到内存），之前于Store2 及所有后续存储指令的存储。
LoadStoreBarriers	Load1; LoadStore; Store2	确保Load1数据装载，之前于Store2及所有后续的存储指令刷新到内存。
StoreLoadBarriers	Store1; StoreLoad; Load2	确保Store1数据对其他处理器变得可见（指刷新到内存），之前于Load2 及所有后续装载指令的装载。StoreLoad Barriers会使该屏障之前的所有内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。

StoreLoad Barriers是一个“全能型”的屏障，它同时具有其他三个屏障的效果。现代的多处理器大都支持该屏障（其他类型的屏障不一定被所有处理器支持）。执行该屏障开销会很昂贵，因为当前处理器通常要把写缓冲区中的数据全部刷新到内存中（buffer fully flush）。

总结：Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序，从而让程序按我们预想的流程去执行：

保证特定操作的执行顺序；
影响某些数据（或则是某条指令的执行结果）的内存可见性。

5、Happens-Before规则

上面的内容讲述了重排序原则，一会是编译器重排序一会是处理器重排序，如果让程序员再去了解这些底层的实现以及具体规则，那么程序员的负担就太重了，严重影响了并发编程的效率。

因此，JMM为程序员在上层提供了happens-before规则，这样我们就可以根据规则去推论跨线程的内存可见性问题，而不用再去理解底层重排序的规则。程序员对于两个操作指令是否真的被重排序并不关心，程序员关心的是程序执行时的语义不能被改变（即执行结果不能被改变）。

从JDK5开始，java使用happens-before的概念来阐述操作之间的内存可见性。在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在happens-before关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。

两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。

与程序员密切相关的happens-before规则如下：

程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作；
监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁；
volatile变量规则：对一个volatile域的写，happens- before 于任意后续对这个volatile域的读；
传递性：如果A happens- before B，且B happens- before C，那么A happens- before C；
线程start()规则：主线程A启动线程B，线程B中可以看到主线程启动B之前的操作。也就是start() happens before 线程B中的操作；
线程join()规则：主线程A等待子线程B完成，当子线程B执行完毕后，主线程A可以看到线程B的所有操作。也就是说，子线程B中的任意操作，happens-before join()的返回。

参考资料：

[1] 程晓明. 深入理解Java内存模型
[2] 周志明. 深入理解JVM虚拟机
[3] 程晓明,方腾飞,魏鹏. java并发编程的艺术