Java内存模型

一、CPU的缓存结构

我们知道CPU的运算速度是很快的，因为从磁盘读取数据的速度严重影响着效率，所以才有了内存，但是即便是这样，内存的性能也远远跟不上CPU的运行速度，所以CPU的设计者开始在内部加入 高速缓存（SRAM），来解决CPU运算速度和内存IO不匹配的问题。

• 寄存器（Register）：寄存器是CPU内部的存储器，访问速度非常快，通常在纳秒级别（几纳秒至十几纳秒）
• CPU高速缓存，用的是一种叫SRAM（Static Random-Access Memory，静态随机存储器）的芯片。我们经常说的三级缓存就是这里，分为L1、L2、L3三层，其中L1 Cache包括数据缓存和指令缓存，L1是三级缓存离CPU最近的，所以是三级缓存里面最快的。
• 内存，用的是一种叫做DRAM（Dynamic Random-Access Memory，动态随机存储器）的芯片。它使用电容器来存储数据，需要定期刷新以保持数据的有效性。DRAM的容量较大且相对廉价，但读写速度相对较慢。
• 固态硬盘，SSD（Solid-state disk），结构和内存类似，但是它比内存的优点是断电后数据还是存在的，而内存、寄存器、高速缓存断电后数据都会丢失。内存的读写速度比SSD大概快10~1000倍。
• 机械硬盘（Hard Disk Drive，HDD），它是通过物理读写的方式来访问数据的，因此它的访问速度是非常慢的，访问时间是毫秒（ms）级别的。

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

作为高速缓存，它的大小和成本都使得缓存的空间有限。我们将要用的数据放在更加接近CPU的地方，这样每次读取的时候不需要从内存中去拿。一般CPU为我们提供了三级缓存，一般称为L1、L2、L3。其中L1P-用于存放程序（program），L1D-用于存放数据（data）。L1和L2是单核独占的，而L3是单个CPU里面的多核共享的。CPU在获取数据的时候，会先从L1找，找不到再去L2，L3，内存这个顺序依次找到为止。

为什么CPU会有L1、L2、L3这样的缓存设计？主要是因为现在的处理器太快了，而从内存中读取数据实在太慢（一个是因为内存本身速度不够，另一个是因为它离CPU太远了，总的来说需要让CPU等待几十甚至几百个时钟周期），这个时候为了保证CPU的速度，就需要延迟更小速度更快的内存提供帮助，这就是缓存。

二、缓存一致性问题（Cache Coherence）

因为CPU多核的存在，然后每个核都有自己独立的工作空间，所以当两个核都需要处理同一个内存中的数据时，它们都会将数据从主内存拷贝到自己的缓存中，我们先把这块叫做工作内存，如果这两个核对应的线程都需要修改这个值的时候，那么就会出现问题，当处理完成后，我们还是要将数据写会到缓存中去的，但是因为这两个互相独立的核，它们都写回的话，肯定会有一个被另外一个给覆盖了。

1、怎么解决？

为了解决一致性的问题，需要各个处理器访问缓存时都遵循一些协议，在读写时要根据协议来进行操作，这类协议有MSI、MESI、MOSI、Synapse、Firefly、Dragon Protocol等。

2、MESI

通过锁定缓存行的方式来保证多核CPU和内存读写的一致性问题。其方案类似于读写锁的方式，使得针对于同一地址的读内存操作是并发的，而针对同一地址的写内存操作是独占的。

MESI 是Modified、Exclusive、Shared、Invalid这四个单词的首字母。这四个字母分别代表四种状态：

状态	描述	监听任务
Modified（修改）	该缓存行有效，但是该缓存数据已经被当前核修改，此时和主内存中数据不一致。我们将其置为M，其他的核中缓存行都会置为I。	监听总线上所有对该缓存行写回内存的操作（不希望别人写入），需要将该操作延迟到自己将缓存行写回到主内存后变成S状态。
Exclusive（互斥）	该缓存行有效，数据和内存中的数据一致，数据只存在当前内核工作内存中，只有他在使用时独占的。	监听总线上所有从内存读取该缓存行的操作，一旦有读的，需要将状态置为S状态。
Shared（共享）	该缓存行有效，不过当前缓存行在多个核中都有，并且大家以及内存中的都一样	监听其它的缓存中将该缓存置为I或者为E的事件，将状态置为I状态。
Invalid（无效）	表明该缓存行无效，如果想要获取数据的话，就去主内存中加载最新的	不要监听

缓存行

在CPU缓存中最小的存储单元称为缓存行（cache line），一般大小为64B。我们需要在缓存行中保存上面的4种状态，所以一个缓存行中，都只要有2个Bit位去存储该状态（下图Flag标志位，Tag用来定位缓存行位置）。

三、Java 内存模型（Java Memory Model，JMM）

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量（Variables）与Java编程中所说的变量有所区别，它包括了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然也就不会存在竞争问题。

1、主内存与工作内存

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

 2、内存间交互操作

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

• lock（锁定）：作用于主内存中的变量，一个变量在同一时间只能一个线程独占，该操作表示这条线程独占这个变量。
• unlock(解锁)：作用于主内存的变量，表示这个变量的状态由处于锁定状态被释放，这样其他线程能对该变量进行锁定。
• read(读取)：作用于主内存变量，表示把一个主内存变量的值传输到线程的工作内存，以便随后的load操作使用。
• load(载入)：作用于线程的工作内存的变量，表示把read操作从主内存中读取的变量的值放到工作内存的副本中（副本相对于主内存的变量而言的）
• use（使用）：作用于线程的工作内存的变量，表示把工作内存中的一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时就会执行该操作
• assign（赋值）：作用于线程的工作内存中的变量，表示把执行引擎返回的结果赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的字节码指令时就会执行该操作
• store（存储）：作用于线程的工作内存中的变量，把工作内存中的一个变量的值传递给主内存，以便随后的write操作使用
• write（写入）：作用于主内存中的变量，把store操作从工作内存中得到的变量的值放入到主内存的变量中

注意：如果要把一个变量从主内存复制到工作内存，那就要顺序地执行read和load操作，如果要把变量从工作内存同步回主内存，就要顺序地执行store和write操作。注意，Java内存模型只要求上述两个操作必须按顺序执行，而没有保证是连续执行。也就是说，read与load之间，store与write之间是可以插入其他指令的，如对内存中的变量a、b进行访问时，一种可能出现的顺序是read a、read b、load a、loadb。

除此之外，Java内存模型还规定了在执行上述8种操作时必须满足如下规则：

• 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但工作内存不接受，或者从工作内存发起回写了但主内存不接受的情况出现。
• 不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存
• 不允许一个线程回写没有修改的变量到主内存，即不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中。
• 变量只能在主内存中产生，即不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，换句话说，就是对一个变量实施use、store操作之前，必须先执行过了assign和load操作。
• 一个变量在同一时刻只能被一个线程对其进行lock操作，也就是说一个线程一旦对一个变量加锁后，在该线程没有释放掉锁之前，其他线程是不能对其加锁的，但是同一个线程对一个变量加锁后，可以继续加锁，同时在释放锁的时候释放锁的次数必须和加锁次数相同。
• 对变量执行lock操作，就会清空工作空间该变量的值，执行引擎使用这个变量之前，需要重新load或assign操作初始化变量的值
• 不允许对没有lock的变量执行unlock操作，如果一个变量没有被lock操作，那也不能对其执行unlock操作，当然一个线程也不能对被其他线程lock的变量执行unlock操作
• 对一个变量执行unlock之前，必须先把变量同步回主内存中，也就是执行store和write操作。

3、对volatile型变量的特殊规则

关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制。Java内存模型对volatile专门定义了一些特殊的访问规则。在介绍这些比较拗口的规则定义之前，先用比较通俗易懂的语言来介绍一下这个关键字的作用。

当一个变量定义为volatile之后，它将具备两种特性：

• 第一是保证此变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，普通变量的值在线程间传递均需要通过主内存来完成，例如，线程A修改一个普通变量的值，然后向主内存进行回写，另外一条线程B在线程A回写完成之后再从主内存进行读取操作，新变量值才会对线程B可见。
• 第二是禁止指令重排序优化，普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，这也就是Java内存模型中描述的所谓的“线程内表现为串行的语义（WithIn Thred As-If-Serial Semantics）”

 特殊规则：

假设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修饰的变量的运算在并发下是线程安全的。

这个观点的论据是正确的，但是根据论据得出的结论是错误的，并不能得出这样的结论。volatile的规则保证了read、load、use的顺序和连续性，同理assign、store、write也是顺序和连续的。也就是这几个动作是原子性的，但是对变量的修改或者对变量的运算，却不能保证是原子性的。如果对变量的修改是分多个步骤的，那么多线程同时从主内存拿到的值是最新的，但是经过多步运算后回写到主内存的值是有可能存在覆盖情况发生的。例如：

public class VolatileTest {
  public static volatile int race = 0;
  public static void increase() {
    race++
  }

  private static final int THREADS_COUNT = 20;

  public void static main(String[] args) {
      Thread[] threads = new Thread[THREADS_COUNT);
      for (int = 0; i < THREADS_COUNT; i++) {
          threads[i] = new Thread(new Runnable(){
              @Override
              public void run() {
                  for (int j = 0; j < 10000; j++) {
                     increase();
                  }
              }
          });
          threads[i].start();
      }
      while (Thread.activeCount() > 1) {
         Thread.yield();
      }
      System.out.println(race);
  }
}

代码是对volatile类型的变量启动了20个线程，每个线程对于变量执行1w次加1操作，如果volatile变量并发操作没有问题的话，那么结果应该是输出20w，但是结果运行的时候每次都是小于20w，这就是因为race++操作不是原子性的，是分多个步骤完成的。假设两个线程a、b同时取到了主内存的值放到各自的工作内存中，是0，这是没有问题的，在进行++操作的时候假设线程a执行到一半，线程b执行完了，这时线程race的值变为了1（因为线程b对race进行了+1操作，线程b执行完了，线程a还未执行完），然后线程a嗅探到race的值发生了变化，就会把线程a工作线程中的race变量的副本置为无效，导致线程a中的++操作无效。所以导致了最终的值要小于20w（可参考讲解视频：一堂课让你了解原子性问题_哔哩哔哩_bilibili）。

跟其他保证并发安全的工具相比，volatile的性能确实会好一些。在某些情况下，volatile的同步机制性能要优于锁（使用synchronized关键字或者java.util.concurrent包中的锁）。但是现在由于虚拟机对锁的不断优化和实行的许多消除动作，很难有一个量化的比较。

与自己相比，就可以确定一个原则：volatile变量的读操作和普通变量的读操作几乎没有差异，但是写操作会性能差一些，因为要在本地代码中插入许多内存屏障指令来禁止指令重排序，保证处理器不发生乱序执行行为。

4、long和double变量的特殊规则

        Java内存模型要求lock、unlock、read、load、use、assign、store、write这8个操作都具有原子性，但是对于64位的数据类型（long和double），在模型中特别定义了一条相对宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read和write这4个操作的原子性，这点就是所谓的long和double的非原子性协定。

        如果有多个线程共享一个并未声明为volatile的long或double类型的变量，并且同时对它们进行读取和修改操作，那么某些线程可能会读取到一个既非原值，也不是其他线程修改值的代表了“半个变量”的数值。

        不过这种读取到“半个变量”的情况非常罕见（在目前商用Java虚拟机中不会出现），因为Java内存模型虽然允许虚拟机不把long和double变量的读写操作实现成原子操作，但允许虚拟机选择把这些操作实现为具有原子性的操作，而且还强烈建议虚拟机这样实现。在实际开发中，目前各种平台下的商用虚拟机几乎都选择把64位数据的读写操作作为原子操作来对待，因此我们在编写代码时一般不需要把用到long和double变量专门声明为volatile。

5、原子性、可见性与有序性

原子性（Atomicity）

由Java内存模型来直接保证原子性变量操作包括 read、load、use、assign、store、write这6个动作，虽然存在long和double的特例，但基本可以忽略不计，目前虚拟机都对其实现了原子性。如果需要更大范围的控制，lock和unlock也可以满足需求。lock和unlock虽然没有被虚拟机直接开给用户使用，但是提供了字节码层次的指令monitorenter和monitorexit对应这两个操作，对应到java代码就是synchronized关键字，因此synchronized块之间的代码都具有原子性。

可见性（Visibility）

可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。正如前面所说，volatile类型的变量在修改后会立即同步给主内存，在使用的时候会从主内存重新读取，是依赖主内存为中介来保证多线程下变量对其他线程的可见性的。

除了volatile，synchronized和final也可以实现可见性。synchronized关键字是通过unlock之前必须把变量同步回主内存来实现的；而被final修饰的字段在构造器一旦初始化完成，并且构造器没有把“this”的引用传递出去（this引用逃逸是一件很危险的事情，其他线程有可能通过这个引用访问到“初始化了一半”的对象），那在其他线程中就能看到final字段的值。如代码所示，变量i与j都具备可见性，它们无序同步就能被其他线程正确访问：

public static final int i;
public final int j;

static{

    i=0;
    //do something
}

{
//也可以选择在构造函数中初始化
j=0;
//do something

}

有序性（Ordering）

有序性从不同角度来看是不同的。单纯单线程来看都是有序的，但到了多线程就会跟我们预想的不一样。可以这么说：如果在本线程内部观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句说的就是“线程内表现为串行的语义”，后半句指的是”指令重排序“现象和主内存与工作内存之间同步存在延迟的现象。

保证有序性的关键字有volatile和synchronized，volatile禁止了指令重排，而synchronized由”一个变量在同一时刻只能被一个线程对其进行lock操作“来保证。

总体来看，synchronized对三种特性都支持，虽然简单，但是如果无控制的滥用对性能就会产生较大影响。

6、先行发生原则（hanppens-before）

Java语言有一个”先行发生“原则。这个原则非常重要，它是判断数据是否存在竞争、线程是否安全的重要依据，依靠这个原则，我们可以通过几条规则一揽子地解决并发环境下两个操作之间是否可能存在冲突的所有问题。

先行发生是Java内存模型中定义的两项操作之间的偏序关系，如果操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响被操作B观察到，”影响“包括修改了内存中共享变量的值、发送了消息、调用了方法等。

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

• 程序次序规则（Program Order Rule）：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。准确地说，应该是控制流顺序而不是程序代码顺序，因为要考虑分支、循环等结构。
• 管程锁定规则（Monitor Lock Rule）：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是同一个锁，而”后面“是指时间上的先后顺序。
• volatile变量规则（Volatile Variable Rule）：对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的”后面“是指时间顺序上的先后顺序。
• 线程启动规则（Thread Start Rule）：Thread对象的start()方法先行发生于此线程的每一个动作。
• 线程终止规则（Thread Termination Rule）：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。
• 线程中断规则（Thread Interruption Rule）：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测到是否有中断发生。
• 对象终结规则（Finalizer Rule）：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始
• 传递性（Transitivity）：如果操作A先行发生于操作B，操作B先行发生于操作C，那么操作A先行发生于操作C。

四、问题

1、final怎么保证了可见性

如果一个类包含了final字段，且在构造函数中初始化，那么正确地构造一个对象后，final字段被设置后对于其他线程是可见的。

这里所说的正确构造对象，意思是在对象的构造过程中，不允许对该对象进行引用，不然的话，可能存在其它线程在对象还没构造完成时就对该对象进行访问，造成不必要的麻烦。

class FinalFileExample{
    final int x;
    int y;
    static FinalFieldExample f;
    public FinalFieldExample(){
        x=3;
        y=4;

    }

    static void writer(){
        f=new FinalFieldExample();
    }



    static void reader(){
        if(f!=null){
           int i=f.x;
           int j=f.y;
        }
    }

}

上面这个例子描述了应该如何使用final字段，一个线程A执行reader方法，如果f已经在线程B初始化好，那么可以确保线程A看到x值是3，因为它是final修饰的，而不能确保看到y的值是4。

 如果构造函数是下面这样的：

public FinalFileExample(){
    x=3;
    y=4;
    //bad construction- allowing this to escape
    global.obj=this;

}

这样通过global.obj拿到对象后，并不能保证x的值是3。

2、为什么内存读写性能一定高于磁盘

磁盘和内存的读取速度可能相差万倍，内存访问是纳秒级别，磁盘访问是毫秒级别的。

内存（RAM）的读写速度比磁盘（硬盘或固态硬盘）快的主要原因有以下几点：

• 访问速度， 内存是电子存储介质，可以在纳秒级别（10^-9秒）的时间内完成读写操作。而磁盘是机械设备，需要寻找和移动读写头，这会导致较高的延迟，通常在毫秒级别（10^-3秒）或更长的时间内完成读写。
• 物理性能 ，内存芯片位于计算机主板上，与处理器之间的距离非常近，数据传输路径很短。而磁盘通常是通过数据线连接到主板，数据传输路径较长，因此内存的物理性能更高。
• 读写方式， 内存以随机存取的方式工作，可以直接通过内存地址访问任何数据。这使得内存的读写速度不受数据位置的影响。磁盘则需要按照物理磁道上的顺序读取数据，因此在读取大量非连续数据时会有明显的性能下降。