Java虚拟机08——Java内存模型与线程

时间 2019-11-09

标签 java 虚拟机内存模型线程栏目 Java 繁體版

原文原文链接

硬件的效率与一致性

绝大多数的运算任务都不可能只靠处理器“计算”就能完成，处理器至少要与内存交互，如读取运算数据、存储运算结果等。因为计算机的存储设备与处理器的运算速度有接数量级的差距，因此现代计算机系统都不得不加入一层读写速度尽量接近处理器运算速度的高速缓存（Cache）来做为内存与处理器之间的缓冲：将运算须要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存中，这样处理器就无需等待缓慢的内存读写了。java

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但它引入了一个新的问题：缓存一致性（Cache Coherence）。在多处理器系统中，每一个处理器都有本身的高速缓存，而它们又共享同一主内存（Main Memory），当多个处理器的运算任务都涉及同一块主内存区域时，将可能致使各自的缓存数据不一致的问题。为了解决这个问题，须要遵循一些协议，如MSI、MESI、MOSI、Synapse、Firefly及Dragon Protocol等。数据库

除了增长高速缓存外，为了使得处理器内部的运算单元能尽可能被充分利用，处理器可能会对输入代码进行乱序执行（Out-Of-Order Execution）优化，处理器会在计算以后将乱序执行的结果重组，保证该结果与顺序执行的结果是一致的。与此相似的是Java虚拟机中的指令重排序（Instruction Reorder）编程

Java内存模型

Java虚拟机规范中试图定义一种Java内存模型（Java Memory Model，JMM）来屏蔽掉各类硬件和操做系统的内存访问差别，以实现让Java程序在各类平台下都能达到一致的内存访问效果。数组

主内存与工做内存

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

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

这里所讲的主内存、工做内存与Java内存区域中的Java堆、栈、方法区等并非同一个层次的内存划分，这二者基本上是没有关系的，若是二者必定要勉强对应起来，那从变量、主内存、工做内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分，而工做内存则对应于虚拟机栈中的部分区域。从更低层次上说，主内存就直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机（甚至是硬件系统自己的优化措施）可能会让工做内存优先存储于寄存器和高速缓存中，由于程序运行时主要访问读写的是工做内存。多线程

内存间交互操做

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之间是可插入其余指令的。除此以外，Java内存模型还规定了在执行上述8种基本操做时必须知足以下规则：app

不容许read和load、store和write操做之一单独出现，即不容许一个变量从主内存读取了但工做内存不接受，或者从工做内存发起回写了但主内存不接受的状况出现。
不容许一个线程丢弃它的最近的assign操做，即变量在工做内存中改变了以后必须把该变化同步回主内存。
不容许一个线程无缘由地（没有发生过任何assign操做）把数据从线程的工做内存同步回主内存中。
一个新的变量只能在主内存中“诞生”，不容许在工做内存中直接使用一个未被初始化（load或assign）的变量，换句话说，就是对一个变量实施use、store操做以前，必须先执行过了assign和load操做。
一个变量在同一个时刻只容许一条线程对其进行lock操做，但lock操做能够被同一条线程重复执行屡次，屡次执行lock后，只有执行相同次数的unlock操做，变量才会被解锁。
若是对一个变量执行lock操做，那将会清空工做内存中此变量的值，在执行引擎使用这个变量前，须要从新执行load或assign操做初始化变量的值。
若是一个变量事先没有被lock操做锁定，那就不容许对它执行unlock操做，也不容许去unlock一个被其余线程锁定住的变量。
对一个变量执行unlock操做以前，必须先把此变量同步回主内存中（执行store、write操做）

volatile

关键字volatile能够说时Java虚拟机提供的最轻量级的同步机制，当一个变量定义为volatile以后，它将具有两种特性：函数

1.保证此变量对全部线程的可见性，这里的“可见性”是指当一条线程修改了这个值，新值对于其余线程来讲是能够当即得知的

volatile变量在各个线程的工做内存中不存在一致性问题（在各个线程的工做内存中，volatile变量也能够存在不一致的状况，可是因为每次使用以前都会先刷新，执行引擎看不到不一致的状况，所以能够认为不存在一致性问题），可是基于volatile变量的运算在并发下同样是不安全的。

public class VolatileTest {
    public static volatile int race = 0;

    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    increase();
                }
            });
            threads[i].start();
        }
        // 等待全部累加线程都结束
        while (Thread.activeCount()>1) {
            Thread.yield();
        }
        System.out.println(race);
    }
}
复制代码

运行结果以下：

这段代码启动了20个线程，每一个线程进行10000次自增操做，若是正确并发的话应该是输出200000，可是发现每次运行结果都是小于200000的值，这是为何呢？

问题就出如今自增运算race++不是原子操做，会产生4条指令getstatic、iconst_一、iadd、putstatic，当getstatic指令把race的值取到操做栈顶时，volatile关键字只保证了此时的值是正确的，在执行++操做的时候，其余线程可能把race的值加大了，而在操做栈顶的值就变成了过时的数据，所以就可能把较小的值同步回主内存中。

因为volatile变量只能保证可见性，在不符合如下两条规则的运算场景中，咱们仍然要经过加锁（使用synchronized或java.util.concurrent中的原子类）来保证原子性：

运算结果并不依赖变量的当前值，或者可以确保只有单一的线程修改变量的值。
变量不须要与其余的状态变量共同参与不变约束。

如如下场景,调用shutdown能当即中止工做。

volatile boolean shutdownRequested;
    public void shutdown() {
        shutdownRequested = false
    }
    public void dowork() {
        while(!shutdownRequested){
            // do something
        }
    }
复制代码

2.使用volatile变量的第二个语义是禁止指令重排序优化，普通的变量仅仅会保证在该方法的执行过程当中全部依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操做的顺序与程序代码中的执行顺序一致。由于在一个线程的方法执行过程当中没法感知到这点，这也就是Java内存模型中描述的所谓的“线程内表现为串行的语义”（Within-Thread As-If-Serial Semantics）

Java内存模型中对volatile变量定义的特殊规则。假定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的load、read动做相关联，必须连续一块儿出现（这条规则要求在工做内存中，每次使用V前都必须先从主内存刷新最新的值，用于保证能看见其余线程对变量V所作的修改后的值）。
只有当线程T对变量V执行的前一个动做是assign的时候，线程T才能对变量V执行store动做；而且，只有当线程T对变量V执行的后一个动做是store的时候，线程T才能对变量V执行assign动做。线程T对变量V的assign动做能够认为是和线程T对变量V的store、write动做相关联，必须连续一块儿出现（这条规则要求在工做内存中，每次修改V后都必须马上同步回主内存中，用于保证其余线程能够看到本身对变量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修饰的变量不会被指令重排序优化，保证代码的执行顺序与程序的顺序相同）。

原子性、可见性与有序性

原子性(Atomicity)

由Java内存模型来直接保证的原子性变量操做包括read、load、assign、use、store和write，咱们大体能够认为基本数据类型的访问读写是具有原子性的。

若是应用场景须要一个更大范围的原子性保证，Java内存模型还提供了lock和unlock操做来知足这种需求，尽管虚拟机未把lock与unlock操做直接开放给用户使用，可是却提供了更高层次的字节码指令monitorenter和monitorexit来隐匿地使用这两个操做，这两个字节码指令反映到Java代码中就是同步块—synchronized关键字，所以在synchronized块之间的操做也具有原子性。

可见性(Visibility)

可见性是指当一个线程修改了共享变量的值，其余线程可以当即得知这个修改。Java内存模型是经过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存做为传递媒介的方式来实现可见性的，不管是普通变量仍是volatile变量都是如此，普通变量与volatile变量的区别是，volatile的特殊规则保证了新值能当即同步到主内存，以及每次使用前当即从主内存刷新。所以，能够说volatile保证了多线程操做时变量的可见性，而普通变量则不能保证这一点。

除了volatile以外，Java还有两个关键字能实现可见性，即synchronized和final。同步块的可见性是由“对一个变量执行unlock操做以前，必须先把此变量同步回主内存中（执行store、write操做）”这条规则得到的，而被final修饰的字段在构造器中一旦初始化完成，而且构造器没有把this的引用传递出去（this引用逃逸是一件很危险的事情，其余线程有可能经过这个引用访问到“初始化了一半”的对象），那在其余线程中就能看见final字段的值。

有序性(Ordering)

Java程序中自然的有序性能够总结为一句话：若是在本线程内观察，全部的操做都是有序的；若是在一个线程中观察另外一个线程，全部的操做都是无序的。前半句是指“线程内表现为串行的语义”（Within-Thread As-If-Serial Semantics），后半句是指“指令重排序”现象和“工做内存与主内存同步延迟”现象。

Java语言提供了volatile和synchronized两个关键字来保证线程之间操做的有序性，volatile关键字自己就包含了禁止指令重排序的语义，而synchronized则是由“一个变量在同一个时刻只容许一条线程对其进行lock操做”这条规则得到的，这条规则决定了持有同一个锁的两个同步块只能串行地进入。

先行发生原则

先行发生（happens-before）的原则是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，咱们能够经过几条规则解决并发环境下两个操做之间是否可能存在冲突的全部问题。

先行发生是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的结论。

Java与线程

线程是比进程更轻量级的调度执行单位，线程的引入，能够把一个进程的资源分配和执行调度分开，各个线程既能够共享进程资源（内存地址、文件I/O等），又能够独立调度（线程是CPU调度的基本单位）

线程的实现

系统平台实现线程主要有3种方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现。

使用内核线程实现

内核线程（Kernel-Level Thread,KLT）就是直接由操做系统内核支持的线程，这种线程由内核来完成线程切换，内核经过操纵调度器（Scheduler）对线程进行调度，并负责将线程的任务映射到各个处理器上。每一个内核线程能够视为内核的一个分身，这样操做系统就有能力同时处理多件事情，支持多线程的内核就叫作多线程内核（Multi-Threads Kernel）。

程序通常不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程（Light Weight Process，LWP），轻量级进程就是咱们一般意义上所讲的线程，因为每一个轻量级进程都由一个内核线程支持，所以只有先支持内核线程，才能有轻量级进程。这种轻量级进程与内核线程之间1比1的关系称为一对一的线程模型，以下图所示：

因为内核线程的支持，每一个轻量级进程都成为一个独立的调度单元，即便有一个轻量级进程在系统调用中阻塞了，也不会影响整个进程继续工做，可是轻量级进程具备它的局限性：首先，因为是基于内核线程实现的，因此各类线程操做，如建立、析构及同步，都须要进行系统调用。而系统调用的代价相对较高，须要在用户态（User Mode）和内核态（Kernel Mode）中来回切换。其次，每一个轻量级进程都须要有一个内核线程的支持，所以轻量级进程要消耗必定的内核资源（如内核线程的栈空间），所以一个系统支持轻量级进程的数量是有限的。

使用用户线程实现

从广义上讲，一个线程只要不是内核线程，就能够认为是用户线程（User Thread,UT）。从狭义上的用户线程指的是彻底创建在用户空间的线程库上，系统内核不能感知线程存在的实现。用户线程的创建、同步、销毁和调度彻底在用户态中完成，不须要内核的帮助。若是程序实现得当，这种线程不须要切换到内核态，所以操做能够是很是快速且低消耗的，也能够支持规模更大的线程数量，部分高性能数据库中的多线程就是由用户线程实现的。这种进程与用户线程之间1比N的关系称为一对多的线程模型，以下图所示：

使用用户线程的优点在于不须要系统内核支援，劣势也在于没有系统内核的支援，全部的线程操做都须要用户程序本身处理。于是使用用户线程实现的程序通常都比较复杂，如今使用用户线程的程序愈来愈少了，Java、Ruby等语言都曾经使用过用户线程，最终又都放弃使用它。

使用用户线程加轻量级进程混合实现

这种混合实现下，既存在用户进程也存在轻量级进程。用户线程的建立、切换、析构等操做依然廉价，而且能够支持大规模的用户线程并发。而用户线程的系统调用经过轻量级线程来完成，大大下降了整个进程被彻底阻塞的风险。这种混合模式中，用户线程与轻量级进程的数量为N：M的关系

Java线程的实现

虚拟机规范中并未限定Java线程须要使用哪一种线程模型来实现，线程模型只对线程的并发规模和操做成本产生影响，对Java程序的编码和运行过程来讲，这些差别都是透明的。对于Sun JDK来讲，它的Windows版与Linux版都是使用一对一的线程模型实现的，一条Java线程就映射到一条轻量级进程之中，由于Windows和Linux系统提供的线程模型就是一对一的。

Java线程调度

线程调度是指系统为线程分配处理器使用权的过程，主要调度方式有两种，分别是协同式线程调度（Cooperative Threads-Scheduling）和抢占式线程调度（Preemptive Threads-Scheduling）。

若是使用协同式调度的多线程系统，线程的执行时间由线程自己来控制，线程把本身的工做执行完了以后，要主动通知系统切换到另一个线程上。协同式多线程的最大好处是实现简单，并且因为线程要把本身的事情干完后才会进行线程切换，切换操做对线程本身是可知的，因此没有什么线程同步的问题。它的坏处也很明显：线程执行时间不可控制，甚至若是一个线程编写有问题，一直不告知系统进行线程切换，那么程序就会一直阻塞在那里。

若是使用抢占式调度的多线程系统，那么每一个线程将由系统来分配执行时间，线程的切换不禁线程自己来决定（在Java中，Thread.yield()可让出执行时间，可是要获取执行时间的话，线程自己是没有什么办法的）。在这种实现线程调度的方式下，线程的执行时间是系统可控的，也不会有一个线程致使整个进程阻塞的问题，Java使用的线程调度方式就是抢占式调度。

虽然Java线程调度是系统自动完成的，可是能够设置优先级，Java语言一共设置了10个级别的线程优先级（Thread.MIN_PRIORITY至Thread.MAX_PRIORITY）。Java的线程是经过映射到系统的原生线程上来实现的，因此线程调度最终仍是取决于操做系统，虽然如今不少操做系统都提供线程优先级的概念，可是并不见得能与Java线程的优先级一一对应。

状态转换

Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中的一种状态，这5种状态分别以下。

新建（New）：建立后还没有启动的线程处于这种状态。
运行（Runable）：Runable包括了操做系统线程状态中的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
无限期等待（Waiting）：处于这种状态的线程不会被分配CPU执行时间，它们要等待被其余线程显式地唤醒。如下方法会让线程陷入无限期的等待状态：没有设置超时参数的Object.wait()方法。没有设置超时参数的Thread.join()方法。 LockSupport.park()方法。
限期等待（Timed Waiting）：处于这种状态的线程也不会被分配CPU执行时间，不过无须等待被其余线程显式地唤醒，在必定时间以后它们会由系统自动唤醒。如下方法会让线程进入限期等待状态： Thread.sleep()方法。设置了超时参数的Object.wait()方法。设置了超时参数的Thread.join()方法。 LockSupport.parkNanos()方法。 LockSupport.parkUntil()方法。
阻塞（Blocked）：线程被阻塞了，“阻塞状态”与“等待状态”的区别是：“阻塞状态”在等待着获取到一个排他锁，这个事件将在另一个线程放弃这个锁的时候发生；而“等待状态”则是在等待一段时间，或者唤醒动做的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
结束（Terminated）：已终止线程的线程状态，线程已经结束执行。