从单例模式挖到内存模型（四）----java内存模型

java内存模型：

Java内存模型即Java MemoryModel，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。

JDK1.5版本对java的内存模型进行了重构，开始使用新的JSR-133内存模型。

JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory）或叫工作内存，本地内存中存储了该线程以读/写共享变量的副本。

注：本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

 

线程间的通信：

1. 线程A把本地内存A中更新过的共享变量刷新到主内存中去。

2. 线程B到主内存中去读取线程A之前已更新过的共享变量。

 

Java 内存模型中的可见性、原子性和有序性

可见性：

可见性是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就是这个操作同样存在线程安全问题。

在 Java 中 volatile、synchronized 和 final 实现可见性。

原子性：

原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型）这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++；这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。

在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。volatile不保证原子性。

有序性：

Java 语言提供了 volatile 和synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

 

java内存模型中的8种基本操作：

• 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 b， load a。

 

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操作）。

内存屏障

Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。

Java内存模型把内存屏障分为LoadLoad、LoadStore、StoreLoad和StoreStore四种：

LoadLoad屏障：对于这样的语句Load1;LoadLoad; Load2，在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕。

StoreStore屏障：对于这样的语句Store1;StoreStore; Store2，在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见。

LoadStore屏障：对于这样的语句Load1;LoadStore; Store2，在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕。

StoreLoad屏障：对于这样的语句Store1;StoreLoad; Load2，在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的。

 

所谓的JSR-133内存模型

从JDK1.5开始，java使用JSR-133内存模型，直到现在的JDK1.8也依然沿用了JDK1.5时候的内存模型，这种内存模型基于happens-before的概念来阐述操作之间的内存可见性，意思是，如果第一个操作的结果对第二个操作可见，那么这两个操作就必须存在happens-before的关系，但不要求这两个操作在一个线程中进行。

happens-before规则如下：

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

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

3，volatile域规则：对一个volatile域的写操作，happens-before于任意线程后续对这个volatile域的读。

4，传递性规则：如果 Ahappens-before B，且 B happens-before C，那么A happens-before C。

注意：两个操作之间具有happens-before关系，并不意味前一个操作必须要在后一个操作之前执行！仅仅要求前一个操作的执行结果，对于后一个操作是可见的，且前一个操作按顺序排在后一个操作之前。

 

JVM对内存模型的实现方式

以上所说的内存模型，通俗一点说就是有一块内存空间当做主存，共享的变量都放主存里，线程各自有自己的本地内存，用来缓存各自要用的变量，线程之间通过主存进行数据交互。

JVM对此内存模型的实现方式就是：

1，有一块内存空间当做主存，叫做堆内存，

2，线程各自有各自的本地内存，叫线程栈，也叫调用栈。

3，线程栈里包含了当前线程执行的方法调用相关信息，还有当前方法的本地变量信息。

4，各线程只能访问自己的线程栈，不能访问其他线程的线程栈。

5，所有原始类型(boolean,byte,short,char,int,long,float,double)的本地变量都直接保存在线程栈当中，各线程之间独立，但是线程之间可以传输原始类型的副本（还是不能算共享）。

6，非原始类型的对象会被存储到堆中，对这个对象的引用会被存储到栈中。

7，对象的成员方法中的原始类型会被存储到栈中。

8，对象的成员变量，包括原始类型和包装类型，还有static类型的变量，都跟着类本身一起存到堆中。

9，如果某个线程要用对象的原始类型成员变量，会拷贝一份到自己的线程栈中。

10，如果某个线程要用对象的包装类型变量，会直接访问堆。