《深刻理解 Java 虚拟机》读书笔记：Java 内存模型与线程

正文

因为计算机的处理器运算速度与它的存储和通讯子系统速度的差距太大了，大量的时间都花费在磁盘 I/O、网络通讯或者数据库访问上，致使处理器在大部分时间里都处于等待其余资源的状态。所以，为了充分利用计算机的处理器运算能力，现代计算机操做系统采用了多任务处理的方式，即让计算机并发处理多个任务。

对于计算量相同的任务，程序线程并发协调得越有条不紊，效率天然就会越高；反之，线程之间频繁阻塞甚至死锁，将会大大下降程序的并发能力。

1、硬件的效率与一致性

一、高速缓存

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

二、缓存一致性

基于高速缓存的存储交互解决了处理器与内存的速度矛盾，但也引入了一个新的问题：缓存一致性。

在多处理器系统中，每一个处理器都有本身的高速缓存，而它们又共享同一主内存。当多个处理器的运算任务都涉及同一块主内存区域时，将可能致使各自的缓存数据不一致。为了解决一致性的问题，须要各个处理器访问缓存时遵循一些协议，在读写时根据协议来进行操做，好比 MSI、MESI 等协议。

处理器、高速缓存、主内存间的交互关系：

三、乱序执行

除了增长高速缓存以外，为了使处理器内部的运算单元能尽可能被充分利用，处理器可能会对输入代码进行乱序执行优化。处理器会在计算以后将乱序执行的结果重组，保证该结果与顺序执行的结果一致。

2、Java 内存模型

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

一、主内存与工做内存

Java 内存模型规定了全部的变量都存储在主内存中。每条线程还有本身的工做内存，线程的工做内存中保存了被该线程使用到的变量的主内存副本拷贝。

线程对变量的全部操做（读取、赋值等）都必须在工做内存中进行，而不能直接读写主内存中的变量。不一样的线程之间也没法直接访问对方工做内存中的变量，线程间变量值的传递均须要经过主内存来完成。

从定义上来看，主内存主要对应于 Java 堆中的对象实例数据部分，而工做内存则对应于虚拟机栈中的部分区域。

从更低层次上说，主内存直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机（甚至是硬件系统自己的优化措施）可能会让工做内存优先存储于寄存器和高速缓存中，由于程序运行时主要访问读写的是工做内存。

二、内存间交互操做

关于主内存与工做内存之间的交互协议，即一个变量如何从主内存拷贝到工做内存、如何从工做内存同步回主内存之类的实现细节，Java 内存模型中定义了 8 种操做来完成，虚拟机必须保证每一种操做都是原子的、不可再分的。

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

三、对于 volatile 型变量的特殊规则

volatile 的做用：

• 保证变量对全部线程的可见性。即当一条线程修改了某个变量的值，新值对于其余线程来讲是能够当即得知的。
• 禁止指令重排序优化。

volatile 变量只能保证可见性，不能保证原子性。在如下运算场景中，仍然要经过加锁（使用 synchronized 或 java.util.concurrent 中的原子类）来保证原子性：

• 运算结果依赖于变量的当前值，而且其余线程可能会修改变量的值。
• 变量须要与其余的状态变量共同参与不变约束。

对 volatile 变量的特殊规则：

• 某个线程对 volatile 变量的 read、load、use 操做必须连续一块儿出现。这条规则要求在工做内存中，每次使用变量前都必须先从主内存刷新最新的值，用于保证能看见其余线程对变量所作的修改后的值。
• 某个线程对 volatile 变量的 assign、store、write 操做必须连续一块儿出现。这条规则要求在工做内存中，每次修改变量后都必须马上同步回主内存中，用于保证其余线程能够看到本身对变量所作的修改。
• 若是线程 A 的 use、assign 操做先于线程 B，那么线程 A 的 read、write 也必须先于 线程 B。这条规则要求 volatile 变量不会被指令重排序优化，保证代码的执行顺序与程序的顺序相同。

四、对于 long 和 double 型变量的特殊规则

Java 内存模型容许虚拟机将没有被 volatile 修饰的 64 位数据（long 和 double）的读写操做划分为两次 32 位的操做来进行，即容许虚拟机实现能够不保证 64 位数据类型的 load、store、read 和 write 这 4 个操做的原子性，这就是所谓的 long 和 double 的非原子性协定。

目前各平台下的商用虚拟机几乎都把 64 位数据的读写操做实现为具备原子性的操做，所以在编写代码时通常不须要把 long 和 double 变量专门声明为 volatile。

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

Java 内存模型是围绕着在并发过程当中如何处理原子性、可见性和有序性这 3 个特征来创建的。

（1）原子性

• 基本数据类型的访问读写具有原子性（不考虑 long、double 的非原子性协定）： Java 内存模型直接保证了 read、load、assign、use、store 和 write 操做的原子性。
• synchronized 代码块之间的操做具有原子性：底层经过 lock 和 unlock 操做实现。

（2）可见性

可见性是指当一个线程修改了共享变量的值，其余线程可以当即得知这个修改。

Java 内存模型是经过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存做为传递媒介的方式来实现可见性的。

volatile、synchronized、final 关键字都能实现可见性。

（3）有序性

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

Java 语言提供了 volatile、synchronized 关键字来保证线程之间操做的有序性。

六、先行发生原则

先行发生是 Java 内存模型中定义的两项操做之间的偏序关系，若是说操做 A 先行发生于操做 B，其实就是说在发生操做 B 以前，操做 A 产生的影响能被操做 B 观察到。“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等。它是判断数据是否存在竞争、线程是否安全的主要依据。

Java内存模型的先行发生关系：

• 程序次序规则：在一个线程内，按照程序代码顺序，书写在前的操做先行发生于书写在后的操做。准确地说，是控制流顺序而不是程序代码顺序，由于要考虑分支、循环等结构。
• 管程锁定规则：一个 unlock 操做先行发生于后面（时间上的前后顺序）对同一个锁的 lock 操做。
• volatile 变量规则：对一个 volatile 变量的写操做先行发生于后面（时间上的前后顺序）对这个变量的读操做。
• 线程启动规则：Thread 对象的 start() 方法先行发生于此线程的每个动做。
• 线程终止规则：线程中的全部操做都先行发生于对此线程的终止检测，能够经过 Thread.isAlive() 方法检测到线程是否已经终止执行。
• 线程中断规则：对线程 interrupt() 方法的调用先行发生于被中断线程检测到中断事件的发生，能够经过 Thread.interrupted() 方法检测到是否有中断发生。
• 对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
• 传递性：若是操做 A 先行发生于操做 B，操做 B 先行发生于操做 C，那么能够得出操做 A 先行发生于操做 C。

若是两个操做之间的关系不知足以上规则，而且没法从以上规则推导出来，那么它们就没有顺序性保障，虚拟机能够对它们随意地进行重排序。

3、Java 与线程

一、线程的实现

主流的操做系统都提供了线程实现，Java 语言则提供了在不一样硬件和操做系统平台下对线程操做的统一处理，每一个已经执行 start() 且还未结束的 java.lang.Thread 类的实例就表明了一个线程。

（1）使用内核线程实现

内核线程（Kernel-Level Thread，KLT）就是直接由操做系统内核（Kernel）支持的线程，这种线程由内核来完成线程切换，内核经过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。

每一个内核线程能够视为内核的一个分身，这样操做系统就有能力同时处理多件事情，支持多线程的内核就叫作多线程内核。

程序通常不会直接使用内核线程，而是使用内核线程的一种高级接口——轻量级进程（Light Weight Process，LWP），轻量级进程就是一般意义上所讲的线程，每一个轻量级进程都由一个内核线程支持。这种轻量级进程与内核线程之间 1:1 的关系称为一对一的线程模型。

轻量级进程的局限性：

• 因为是基于内核线程实现的，因此各类线程操做，如建立、析构及同步，都须要进行系统调用。而系统调用的代价相对较高，须要在用户态和内核态中来回切换。
• 每一个轻量级进程都须要有一个内核线程的支持，会消耗必定的内核资源（如内核线程的栈空间），所以一个系统支持轻量级进程的数量是有限的。

（2）使用用户线程实现

用户线程（User Thread，UT）彻底创建在用户空间的线程库上，系统内核不能感知线程的存在。用户线程的创建、同步、销毁和调度彻底在用户态中完成，不须要内核的帮助。所以操做快速且低消耗，也能够支持规模更大的线程数量。这种进程与用户线程之间 1:N 的关系称为一对多的线程模型。

使用用户线程的优点在于不须要系统内核支援，劣势也在于没有系统内核的支援，全部的线程操做都须要用户程序本身处理。所以使用用户线程实现的程序通常都比较复杂。

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

混合实现时，用户线程仍是彻底创建在用户空间中，而操做系统提供支持的轻量级进程则做为用户线程和内核线程之间的桥梁。在这种混合模式中，用户线程与轻量级进程的数量比是不定的，即为 N:M 的关系，这种就是多对多的线程模型。

混合实现的好处：

• 用户线程的操做依然廉价，而且能够支持大规模的用户线程并发。
• 可使用内核提供的线程调度功能及处理器映射。
• 因为用户线程的系统调用要经过轻量级进程来完成，所以大大下降了整个进程被彻底阻塞的风险。

二、Java 线程调度

线程调度是指系统为线程分配处理器使用权的过程，主要调度方式有两种：协同式线程调度和抢占式线程调度。

（1）协同式线程调度

线程的执行时间由线程自己来控制，线程执行完以后，主动通知系统切换到另一个线程上。

协同式线程调度最大的好处是实现简单，并且切换线程的操做对线程本身是可知的，因此没有什么线程同步的问题。它的坏处就是线程执行时间不可控，若是一个线程编写有问题，一直不告知系统进行线程切换，那么程序就会一直阻塞在那里。

（2）抢占式线程调度

每一个线程由系统来分配执行时间，线程的切换不禁线程自己来决定。

使用抢占式线程调度时，线程的执行时间是系统可控的，不会有一个线程致使整个进程阻塞的问题。

Java 使用的线程调度方式就是抢占式调度。

三、线程状态

（1）6 种线程状态

• 新建（New）：建立后还没有启动的线程处于这种状态。
• 运行（Runable）：包括了操做系统线程状态中的 Running 和 Ready，处于此状态的线程有可能正在执行，也有可能正在等待着 CPU 为它分配执行时间。
• 无限期等待（Waiting）：不会被分配 CPU 执行时间，等待着被其余线程显式地唤醒。
• 限期等待（Timed Waiting）：不会被分配 CPU 执行时间，无须等待被其余线程显式地唤醒，在必定时间以后会由系统自动唤醒。
• 阻塞（Blocked）：线程被阻塞了，在等待着获取到一个排他锁。在程序等待进入同步区域的时候，线程将进入这种状态。
• 结束（Terminated）：已终止线程的线程状态，线程已经结束执行。

（2）线程状态转换