第12章 Java内存模型与线程

1.概述

让计算机同时做几件事，一个很重要的原因是计算机的运算速度与它的存储和通信子系统速度差距太大，大量的时间花费在磁盘I/O、网络通信或数据库访问上，所以需要让计算机同时处理几项任务；还有就是一个服务端同时对多个客户端提供服务的场景，每秒事务处理数(TPS)是衡量服务性能好坏的重要指标，它表示一秒内服务端平均能响应的请求总数。

2.硬件的效率与一致性

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

基于高速缓存的存储交互也带来一个新的问题：缓存一致性。在多处理器系统中，每个处理器都有自己的高速缓存，而它们又共享同一主内存。如下图：

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

当多个处理器运算任务都涉及同一块主内存区域时，将可能导致各自的缓存数据不一致，如果真的发生这种情况，那同步回到主内存时以谁的缓存数据为准？为了解决一致性问题，需要各个处理器遵循一些协议：这类协议有MSI、MESI、MOSI、Synapse等等。

"内存模型"：可以理解为在特定的操作协议下，对特定对内存或高速缓存进行读写访问的过程抽象。

除了增加高速缓存，处理器可能会对输入代码进行乱序执行优化，处理器会在计算之后将乱序执行的结果重组，保证该结果与顺序执行的结果是一致的，但不保证程序中各个语句计算的先后顺序与输入代码中的顺序一致。

3.Java内存模型

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

3.1 主内存和工作内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。

此处的变量与Java编程所说的变量有所区别，它包括了实例字段、静态字段、和构成数组对象的元素，但不包括局部变量和方法参数，因为它们是线程私有的，不会被共享，自然没有竞争问题。

Java内存模型规定所有的变量都存储在主内存中，每条线程还有自己的工作内存(可与前面说的处理器高速缓存类比)，线程工作内存中保存了该线程使用的变量的主内存副本拷贝，线程对变量的所有操作(读取、赋值)必须在工作内存中进行，线程间的变量传递均需要通过主内存来完成，线程、主内存、工作内存的交互关系如下图所示：

三者交互关系

3.2内存间的交互操作

关于主内存和工作内存交互协议，(一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存的实现)，Java内存模型定义了8种操作，虚拟机实现必须保证每种操作都是原子的、不可再分。

• lock：锁定，作用于主内存的变量，它把一个变量标识为一条线程独占的状态。

• unlock：解锁，作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

• read：读取，作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存，以便load使用。

• load：加载，作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。

• use：使用，作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量值的字节码指令时，将会执行这个操作。

• assign：赋值，作用于工作内存的变量，它把一个从执行引擎接受到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令是执行这个操作。

• store：存储，作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存，以便write操作使用。

• write：写入，作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

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

• 如果要把一个变量从主内存赋值到工作内存，必须顺序执行read和load，如果要把变量从工作内存同步回主内存，必须顺序执行store和write。这里时顺序执行，并不是说保证连续执行。

• 不允许read和load、store和write操作之一单独出现。

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

• 不允许一个线程无原因的(没有assign操作)把数据从线程的工作内存同步回主内存。

• 一个新的变量只能在主内存中"诞生"，不允许工作内存中直接使用一个为初始化(load或assgin)的变量。即对一个变量实施use、store操作前，必须先执行assign、load操作。

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

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

• 对一个变量unlock前，必须先把此变量同步回主内存中。

3.3对于volatile型变量的特殊规则

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

1.保证此变量对所有线程的可见性。

这里的"可见性"指当一条线程修改了这个变量的值，新值对于其他线程来说是立即得知的。

普通变量不能做到这一点，普通变量的值在线程间传递均需要通过主内存完成。例如：线程A修改了变量的值，向主内存进行回写，只有回写完成后，其他线程再从主内存进行读取操作，新变量值才会对其他线程可见。

这里有一个误解："使用volatile关键字的变量，对所有线程是立即可见的。所以基于volatile的运算在并发下是安全的。"其实Java的运算操作都是非原子的，导致volatile变量的运算在并发下也不是安全的。

例如下面的例子：

public class VolatileTest {

    public static volatile int race = 0;

    public static void increase(){

        race++;
    }

    public 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(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        while (Thread.activeCount() > 1){
            Thread.yield();
        }

        System.out.println(race);
    }
}

PS：我运行的程序停不了。先留个问题。

最后输出的结果应该是200000，但每次实际结果都是小于200000。

问题出现在"race++"自增操作，用javap反编译这段代码后得到如下图所示：

race++字节码

由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们还得通过锁来保证原子性(使用synchronized或concurrent中的原子类)。

• 运算结果并不依赖变量的当前值，或者能确保只有单一的线程修改变量的值。

• 变量不需要与其他的状态变量共同参与不变约束。

如下的代码volatile就很适用，当shutdown()调用时，能保证所有线程中执行的doWork()都立即停下来。

public volatile boolean shutdownRequest;
    
    public void shundown(){
        
        shutdownRequest = true;
    }
    
    public void doWork(){
        
        while(!shutdownRequest){
            //
        }
    }

2.禁止指令重排序优化

普通的变量只能保证该方法的执行过程中所有依赖赋值结果的地方能获取到正确结果，但不能保证变量赋值操作的顺序和代码中执行的顺序一致。

通过一个例子来看看为何指令重排序干扰程序的并发执行：

指令重排序

如上图，如果定义initialized变量时没有使用volatile修饰，就可能发生指令重排序优化，导致线程A中"initialzed=true"提前执行，这样线程B使用配置信息的时候可能会出错。

在看下面的例子：

DCL单例模式

编译后，这段代码对instance变量赋值部分如下图所示：

instance赋值

其实，有volatile修饰的变量，赋值后(mov %eax, 0x150(%esi))多执行了一个"lock addl $0x0, (%esp)"操作，这个操作相当于一个内存屏障：指令重排序时，不能把后面的指令重排序到内存屏障之前。

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

Java内存模型要求lock、unlock、read、load、assign、use、store、write都具有原子性，但对于64位的数据类型(long和double)，定义了比较宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作进行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read、write操作的原子性。

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

原子性

我们大致可以认为基本数据类型的访问读写具备原子性的(long、double除外，无需该在意)。

如果应用场景需要更大范围的原子性保证，Java内存模型还提供了lock、unlock操作来满足这个需求。虽然虚拟机没有把这两个操作直接开放给用户，但是提供了更高层次的字节码指令monitorenter和monitorexit，这两个字节码指令反映到Java代码中就是同步块。synchronized，因此同步块中的操作具备原子性的。

可见性

指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。volatile保证了多线程操作时变量的可见性，普通变量则不能保证这一点。

除了volatile外，Java还有两个关键字能实现可见性：synchronized和final。

同步块的可见性是因为：对一个变量执行unlock前，必须先把此变量同步回主内存中。final的可见性是：被final修饰的字段在构造器中一旦初始化完成，那么在其他线程中就能看到final字段的值。

有序性

如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句是"线程内表现为串行的语义"，后半句是"指令重排序"和"工作内存与主内存同步延迟"。

Java提供volatile和synchronized关键字来保证线程之间操作的有序性，volatile本身包含了禁止指令重排序优化的语义，而synchronized是因为"一个变量在同一时刻只允许一条线程对其进行lock操作"。

3.6先行发生原则

如果Java内存模型的有序性只靠volatile和synchronized完成，那么有一些操作会很繁琐，所以，Java中有一个"先行发生"的原则。

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

Java内存模型中的一些内置的先行发生关系：

• 程序次序规则：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。

• 管程锁定规则：一个unlock操作先行发生与后面对同一个锁的lock操作。

• volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量对读操作。

• 线程启动规则：Thread对象对start()方法先行发生于此线程的每一个动作。

• 线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测，可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止。

• 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生。

• 对象终结规则：一个对象的初始化完成(构造函数执行结束)先行发生于它的finalize()方法的开始。

• 传递性：如果操作A先行发生于操作B，操作B先行发生于操作C，那么操作A就先行发生于操作C。

4.Java与线程

4.1线程的实现

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

实现线程主要有3种方式：

1.使用内核线程实现

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

程序一般不会直接使用内核线程，而去使用内核线程的一种高级接口——轻量级进程(Light Weight Process，LWP)，轻量级进程就是我们所说的"线程"，每个轻量级进程都由一个内核线程支持，轻量级进程与内核线程之间1:1的关系称为一对一的线程模型，如下图所示：

轻量级进程与内核线程之间1:1的关系

由于内核线程的支持，每个轻量级进程都称为一个独立的调度单元，即使有一个轻量级进程在系统调用中阻塞了，也不会影响整个进程继续工作，但是轻量级进程具有它的局限性：由于基于内核线程实现的，所以各种线程操作(创建、析构、同步)都需要进行系统调用。而系统调用的代价相对较高，需要在用户态(User Mode)和内核态(Kernel Mode)中来回切换；再一个就是每个轻量级进程都需要一个内核线程的支持，因此轻量级进程要消耗一定的内核资源(如内核线程的栈空间)，因此一个系统支持轻量进程的数量是有限的。

2.使用用户线程实现

广义上说，一个线程只要不是内核线程，就可以认为是用户线程(User Thread，UT)。所以，这么看的话，轻量级进程也属于用户线程，但轻量级进程的实现始终是建立在内核上的，许多操作都要进行系统调用，效率收到限制。

狭义上的用户线程指完全建立在用户空间的线程库上，用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核帮助。这种线程不需要切换到内核态，因此操作可以非常快速且低耗，支持规模更大的线程数。

用户线程优势在于不需要系统内核支援，劣势也是在于没有系统内核支援。线程的创建、切换和调度都是需要考虑的问题，由于操作系统只把处理器资源分配到进程，如"阻塞如何处理"、"多处理器系统中如何将线程映射到其他处理器上"这类问题解决异常困难。现在使用用户线程的程序越来越少了，Java、Ruby等都曾使用过，但最后都放弃了。

这种进程与用户线程之间是1:N的线程模型。

进程：用户线程=1:N

3.使用用户线程+轻量级进程混合实现

这种混合实现下，既存在用户线程，也存在轻量级进程。用户线程还是完全建立在用户空间中，因此用户线程的创建、切换、析构等操作依然廉价，并且支持大规模的用户线程并发；操作系统提供支持的轻量级进程作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的系统调用通过轻量级进程线程完成，大大降低了整个进程被完全阻塞的风险。

这种混合模式，用户线程与轻量级进程通常是N：M的关系。

用户线程与轻量级进程的关系

4.2 Java线程调度

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

协同式调度的多线程系统

线程的执行时间由线程本身控制，线程把自己的工作执行完后，主动通知系统切换到另一个线程上。由于线程把自己的事情做完后才会进行线程切换，所以没什么线程同步的问题。

缺点：线程执行时间不可由控制。如果一个线程有问题，一直不告知系统进行线程切换，那么程序就一直阻塞在那。

抢占式调度的多线程系统

每个线程由系统分配执行时间，线程的切换不由线程本身决定(Java中，Thread.yield()方法可以让出执行时间，但要获取执行时间，线程本身是没有办法的)。

这种实现方式下，线程的执行时间是系统可控的 ，也不会由一个线程导致整个进程阻塞的问题，Java的线程调度就是抢占式调度。

Java中虽然线程调度是系统完成的，但是我们可以使系统给某些进程多分配一些时间，另外的线程少分配一些。这项操作通过设置线程优先级来完成：Java中一共有10个级别的线程优先级，在两个线程同时Ready状态时，优先级越高的线程越容易被系统选择执行。

4.3 状态转换

Java中定义了5中线程状态，在任意一个时间点，一个线程有且只有其中一种状态：

• 新建(New)：创建后尚未启动的线程处于这种状态。

• 运行(Runable)：Runable包括了操作系统线程状态中的Running和Ready。(也就是处于此状态的线程可能正在执行，也可能正在等待着CPU为它分配时间执行)。

• 无限期等待(Waiting)：处于这种状态的线程不会被分配CPU执行时间，它们要等待被其他线程显示唤醒。以下方法会让线程进入无限期的等待：

没有设置Timeout参数的Object.wait()方法
没有设置Timeout参数的Thread.join()方法
LockSupport.park()方法

• 限期等待(Timed Waiting)：处于这种状态的线程也不会被分配CPU时间，在一定时间后它们由系统自动唤醒。以下方法让线程进入限期等待：

Thread.sleep()
设置了Timeout参数的Object.wait()方法
设置了Timeout参数的Thread.join()方法
LockSupport.parkNanos()
LockSupport.parkUntil()

• 阻塞(Blocked)：线程被阻塞。"阻塞状态"与"等待状态"的区别是："阻塞状态"在等待着获取一个排她锁，这个时间将在另一个线程放弃这个锁的时候发生；"等待状态"是等待一段时间或唤醒的动作发生。

• 结束(Terminated)：已终止线程的状态，线程结束执行。

线程状态转换关系