首先搞清楚一个概念，什么是内存模型？首先来看看如何定义，内存模型：在特定的操作协议下对特定的内存或高速缓存进行读写访问的过程抽象。

处理器内存模型

多数运算中，处理器都要和内存进行交互，如读取数据、存储结果等。由于计算机存储设备和处理器运算速度有几个数量级的差距，所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高缓存Cache来作为内存与处理器之间的缓冲：将运算需要使用的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存中同步回内存，这样处理器就无须等待缓慢的内存读写了。 解决运算冲突却导致了高速缓存的一致性问题。

高缓存Cache引入了缓存的一致性Cache Coherence的问题。在多处理器系统中，每个处理器都有自己的高速缓存，又共享同一主内存，可能导致各自的缓存数据不一致【可见性问题】。需要各处理器访问缓存时遵循一些协议，在读写时根据协议来操作，如MSI，MESI，MOSI，Snapse,Firefly,dRAGON Protocol等。处理器还可能会对输入的代码进行乱序执行优化，之后又将乱序结果重组，保证该结果与顺序执行结果一致，还有指令重排序优化【有序性问题】。

并发编程中两个关键问题

在并发编程中，需要处理两个关键问题：线程之间如何通信及线程之间如何同步（这里的线程是指并发执行的活动实体）。在命令式编程中：

通信是指线程之间以何种机制来交换信息线程之间的通信机制有两种：共享内存和消息传递。

• 在共享内存的并发模型里，线程之间共享程序的公共状态，通过写-读内存中的公共状态进行隐式通信。共享变量可见性
• 在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过发送消息来显式进行通信。

同步是指程序中用于控制不同线程间操作发生相对顺序的机制。

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

Java的并发采用的是共享内存模型，Java线程之间的通信总是隐式进行，整个通信过程对程序员完全透明，而同步总是显式执行。

内存交互操作的三大特性

在正式介绍JMM内存模型之前介绍一下操作的3个特性，Java内存模型是围绕着在并发过程中如何处理这3个特性来建立的，这里先给出定义和基本实现的简单介绍，后面会逐步展开分析。

• 原子性(Atomicity)， 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。即使在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程所干扰。
• 可见性(Visibility) ，是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
• 有序性(Ordering)， 有序性规则表现在以下两种场景: 线程内和线程间

• 线程内，从某个线程的角度看方法的执行，指令会按照一种叫串行（as-if-serial）的方式执行，此种方式已经应用于顺序编程语言。
• 线程间，这个线程观察到其他线程并发地执行非同步的代码时，由于指令重排序优化，任何代码都有可能交叉执行。

Java内存模型的一系列运行规则看起来有点繁琐，但总结起来，是围绕原子性、可见性、有序性特征建立。归根究底，是为实现共享变量的在多个线程的工作内存的数据一致性，多线程并发，指令重排序优化的环境中程序能如预期运行。接下来我们先了解下JMM内存的基本构造再来看它如何处理这一系列问题。

JMM基本结构

在Java中（JDK1.7），所有实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享（共享变量代指实例域，静态域和数组元素）。局部变量（Local Variables），方法定义参数和异常处理器参数等不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。

JMM，Java Memory Model，用来屏蔽掉各种硬件和操作系统之间的内存访问差异，以实现让Java程序在各平台下都能达到一致的内存访问效果。

在此之前，主流程序语言（如C/C++等）直接使用物理硬件和操作系统的内存模型，因此，会由于不同平台上内存模型的差异，有可能导致程序在一套平台上并发完全正常，而在另外一套平台上并发访问却经常出错，因此在某些场景就必须针对不同的平台来编写程序。

JMM主要目标：定义程序中各个共享变量的访问规则，即在虚拟机中将变量存储到内存和从内存取出变量这样的底层细节。

主内存与工作内存

如上图所示，JMM中区分为主内存和工作内存：

• JMM规定所有共享变量均存储在主内存（虚拟机内存的一部分）中。每条线程还有自己的工作内存，类比高速缓存。
• 线程对共享变量的所有操作都在工作内存中，不能直接在主内存中读写操作
• 不同线程之间也不能直接访问对方的工作内存中的共享变量。只能通过主内存来传递变量值

注意：主内存与工作内存和Java内存区域的堆栈方法区等并不是同一个层次的内存划分。工作内存可以理解为本地处理器的高速缓冲区。

内存间交互操作

主内存与工作内存之间具体的交互协议：一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存等的细节。

Java内存模型定义了8种操作来完成，虚拟机实现时必须保证下面提及的每一种操作都是原子操作。对于long 和double类型的变量，store，read，write，load操作在某些平台上允许有例外。

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

整体执行的流程如下：

以上操作，仅保持顺序执行即可，不用保证连续执行。如可能发生 read a read b load b load a。

交互操作冲突

变量操作相关的========================================================

• 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但工作内存不接受，或者从工作内存发起回写了但主内存不接受的情况
• 不允许一个线程丢弃它的最近assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存
• 不允许一个线程无原因的（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中，即不能对变量没做任何操作却无原因的同步回主内存
• 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，就是对一个变量执行use和store之前必须先执行过了load和assign操作

lock操作相关的========================================================

• 一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁，synchronized实现可重入锁的基石
• 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值，synchronized实现可见性的基石
• 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定住的变量，synchronized实现锁的基石
• 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store write）synchronized实现可见性的基石

以上可以完全确定Java程序中哪些内存访问操作在并发下是安全的。

指令重排序

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，也叫做指令重排。接下来分别介绍下指令重排的概念、数据依赖性以及顺序一致性

指令重排序

在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。重排序分3种类型。

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

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

上述的1属于编译器重排序，2和3属于处理器重排序。这些重排序可能会导致多线程程序出现内存可见性问题。

• 对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。
• 对于处理器重排序，JMM的处理器重排序规则会要求Java编译器在生成指令序列时，插入特定类型的内存屏障（Memory Barriers）指令，通过内存屏障指令来禁止特定类型的处理器重排序。

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

现代的处理器使用写缓冲区（工作内存）临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见，所以存在内存不可见性。这也是我们上一篇Blog中讲到的Volatile的作用，让内存可见，其实它还有个作用就是禁止指令重排，我们可以看看指令重排的问题：a=b=0，初始状态

a=1//A1
x=b//A2
b=2//B1
y=a//B2

如果顺序执行，结果应该为

x=0,y=1

但实际结果可能是：

x=y=0

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

=====A和B分别对a，b改值但没有刷新到主内存
a=1  //A
b=2  //B
=====A和B分别从主内存读取
b=0  //A
a=0  //B
====执行运算
x=b=0 //A
y=a=0 //B

从内存操作实际发生的顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为：A1→A2，但内存操作实际发生的顺序却是A2→A1。此时，处理器A的内存操作顺序被重排序了。先读到了b=0