【Java内存模型】-JMM简介

计算机内存模型简介

• 大家都了解计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。

• 也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个简单的例子，比如这段代码：i = i + 1;

• 当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题了。在多核CPU中，每条线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，其实也会出现这种问题，只不过是以线程调度的形式来分别执行的）。本文我们以多核CPU为例。比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？

• 可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。最终结果i的值是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。为了解决缓存不一致性问题，通常来说有以下2种解决方法：

  • （1）通过在总线加LOCK#锁的方式
  • （2）通过缓存一致性协议

Java内存模型

JMM用来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。
JMM需要足够严谨，这样才能让Java的并发内存访问不会产生歧义；要足够宽松，使得虚拟机的实现有足够的自由空间去利用硬件的各种特性（寄存器、高速缓存和指令集中某些特有的指令）来获取更好的执行速度。经过长期的验证和修补，在JDK1.5（实现了JSR-133）发布后，Java的内存模型已经成熟和完善起来了。

• 那么Java内存模型规定了哪些东西呢，它定义了程序中变量的访问规则，往大一点说是定义了程序执行的次序。注意，为了获得较好的执行性能，Java内存模型并没有限制执行引擎使用处理器的寄存器或者高速缓存来提升指令执行速度，也没有限制编译器对指令进行重排序。也就是说，在java内存模型中，也会存在缓存一致性问题和指令重排序的问题。

• Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。

主内存与工作内存

Java内存模型主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程中所说的变量不同，它包含了实例字段，静态字段和构成数组对象的元素，但不包含局部变量和方法参数，因为后者是线程私有的，不会出现竞争问题。为了获取较好的执行性能，JMM并没有限制执行引擎使用处理器的特定的寄存去或缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。

Java内存模型规定了所有变量都存储在主内存-Main Memory中，此处的主内存和之前所说的物理硬件的主内存名字一样，两者也可以类比，但此处仅是虚拟机内存的一部分。
每条线程有自己的工作内存-Working Memory, 可以类比处理器高速缓存，线程的工作内存中保留了该线程使用到的变量的主内存副本的拷贝，线程对变量所有的操作（读取，赋值）都必须在工作内存中进行，不能直接读写主内存中变量。不同的线程之间也无法直接访问对方工作内存中变量。线程间变量值的传递均需要通过主内存来完成。

这里提到的主内存、工作内存和内存区域的堆、栈、方法区并不是同一个层次的内存划分，这两者没有直接的关系，如果强行对应，那么主内存主要对应于Java堆中对象实例数据部分，而工作内存则对应于虚拟机栈中部分区域。从更低层次上说，主内存就直接对应于物理硬件的内存，为了获取更好的运行速度，虚拟机可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写是工作内存。

内存间交互操作

主内存和工作内存之间的交互协议-一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存这类的实现细节，Java内存模型中定义了8种操作来完成，虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的（对于double\long类型的变量，load, store, read和write可能在某些平台上允许有例外，随后会讲到）

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

如果把一个变量从主内存复制到工作内存，需要顺序执行read, load。如果把变量从工作内存同步回主内存，顺序执行store, write。Java内存模型只要求上述两个操作是顺序的，没有要求是连续的。比如read a, read b, load b, load a这是被允许的。除此之外，Java内存模型还规定了在执行上述8种基本操作时必须满足：

• 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但工作内存不接受，或者从工作内存发起回写但主内存不接受的情况出现。

• 不允许一个线程丢弃它最近的assgin操作，即变量在工作内存中改变了之后必须要把改变化同步回主内存。

• 不允许一个线程无原因的（没有发生过任何assign从操作）把数据从线程的工作内存同步回主内存。

• 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或者assign）的变量，换句话说，就是对一个变量实施use, store操作之前，必须先执行过了assign和load操作。

• 一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock之后，只有执行相同次数的unlock操作，变量才会被解锁。

• 如果对一个变量执行lock操作，那将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值。

• 如果一个变量实现没有被lock操作锁定，那就不允许对它执行unlock操作，也不允许unlock一个被其他线程锁定的变量。
  对一个变量执行unlock操作之前，必须先把变量同步回主内存中（执行store、write操作）。

这8种内存访问操作以及上述规则限定，加上volatile的特殊规定，就能够完全确定Java程序中哪些内存的访问操作在并发下是安全的。

Java语言本身对原子性、可见性以及有序性提供了哪些保证呢？

1、原子性

在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。举个例子，请分析以下哪些操作是原子性操作：

x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4

只有语句1是原子性操作，其他三个语句都不是原子性操作。语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及 将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。

• 所以上面4个语句只有语句1的操作具备原子性。也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

• 从上面可以看出，Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

2、可见性

对于可见性，Java提供了volatile关键字来保证可见性。

• 当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

• 另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

3、有序性

　　
在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。