12 Java内存模型与线程

12.1 概述

多任务处理在现代操作系统中几乎已是一项必备的功能。主要体现于如下：

• 计算机的运算速度与它的存储和通信子系统速度的差距太大，大量的时间花费在磁盘I/O，网络通信或者数据库访问上。
• 一个服务端对应多个客户端场景的出现。衡量一个服务性能的高低好坏，每秒事务处理数（Transactions PerSecond，TPS）是很重要的指标之一。它代表了一秒服务端平均能响应的请求总数。

12.2 硬件的效率与一致性

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

• 在多处理器系统中，每个处理器都有自己独立的高速缓存，而它们又共享同一主内存（Main Memory）。

处理器、高速缓存和主内存之间的交互.png

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

12.3 Java内存模型

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

12.3.1 主内存与工作内存

Java内存模型规定了所有变量都存储在主内存中。每条线程都有自己的工作内存，线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存的变量，线程间变量值的传递均需通过主内存来完成。

线程、主内存、工作内存三者的交互关系.png

注意：上面中所说的“线程使用的变量为主内存的副本拷贝”，这里的“拷贝”并不是将整个对象进行拷贝，而是“这个对象的引用、对象中某个在线程中访问到的字段”才是所需“拷贝”的。

12.3.2 内存间交互操作

Java内存模型中定义了如下8中操作来完成主内存拷贝到工作内存以及从工作内存同步到主内存的实现。虚拟机实现时必须保证下面提及的每一种操作都是原子的，不可分割的（除long和double类型之外）。

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

注意：如果要把一个变量从主内存复制到工作内存，那么就要顺序执行read和load操作，如果要把变量从工作内存同步到主内存，就要顺序执行store和write操作。

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

• 不允许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操作）。

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

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

• 保证此变量对所有线程的可见性，即一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。

• 禁止指令重排序优化，通过内存屏障（Memory Barrier，指重排序时不能把后面的指令重排序到内存屏障之前的位置）实现。

• volatile如何保证线程的可见性？
  当一个变量被声明为volatile时，该变量在修改时，会被要求立即将新值刷新到主内存中，当变量在读取时，会被要求重新从主内存中获取最新的数据。

• volatile可以保证线程的可见性，但不能保证线程的安全性。

public class VolatileTest {
    public static volatile int race = 0;
    public static void increase(){
        race ++;
    }
    private static final int THREADS_COUNT = 10;
    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 < 10000; i ++) increase();
                }
            });
            threads[i].start();
        }
        //等待所有累积线程都结束
       while (Thread.activeCount() > 1)
           Thread.yield();

        System.out.println("race: " + race);
    }
}
输出结果：
race: 46269

如上，按理应该输出200000，而结果却为46269。真正出问题的在于increase方法中的race++;并非原子操作。

• 指令重排序

Map configOptions;
char[] configText;
volatile boolean initialized = false;
//假设如下代码为线程A执行
//模拟读取配置信息，当读取完成后将initialized设置为true以通知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText,configOptions);
initialized = true;

//假设如下代码为线程B执行
//等待initialized为true，表示线程A已经配置信息初始化完毕
while (!initialized){
    sleep();
}
//使用线程A中初始化好的配置信息
dosomethingWithConfig();

假如变量initialized没有设置为volatile类型，那么可能存在这样的情况：由于指令的重排序优化，线程A会先执行initialized = true;，再执行初始化语句。这样线程B在使用配置信息的代码就可能出现错误，而volatile关键字可以避免这样的情况发生。

• volatile的应用场景：变量不需要与其他的变量共同参与不变约束

volatile boolean isShutdownRequested;
public void shutdown(){
    isShutdownRequested = true;
}
public void doWork(){
    while (!isShutdownRequested)
        //do stuff
}

• volatile的缺点：volatile变量读操作的性能消耗与普通变量几乎没有什么差别，但是写操作则可能会比较慢点，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

• 除了volatile之外，Java还有两个关键字可以保证线程的可见性，即synchronized和final。
  synchronized：通过加锁的方式保证同一时刻只有一个线程访问共享内存。
  final：被final修饰的字段在构造器中一旦初始化完成，并且构造器没有把“this”的引用传递出去，那么在其他线程就能看到final字段的值。

12.3.4 先行发生原则

先行发生是Java内存模型中定义的两项操作之间的偏序关系。如果说操作A先行发生于操作B，即在发生操作B之前，操作A产生的影响能被操作B观察到。

//线程A执行
i = 1;
//线程B执行
j = i;
//线程C执行
i = 2;

假设只考虑线程A和线程B，那么j的结果一定为1：因为线程A和线程B之间存在先行关系。但如果加入线程C，则无法预测j的结果：可能为1，也可能为2，因为线程A和线程C并不存在先行关系。

常见的先行发生关系

• 程序次序规则（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）：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalizer方法的开始。
• 传递性（Transitivity）：如果操作A先行于操作B，操作B先行于操作C，那么操作A先行于操作C。

private int value = 0;
public void setValue (int value) {
    this.value = value;
}
public int getValue (){
    return value;
}

假设存在线程A和B，线程A调用了“setValue(1)"，然后线程B调用了同一对象”getValue()"，那么线程B的返回值是0还是1？
我们根据上面的规则来分析：由于两个方法分别是线程A和线程B调用，不在一个线程中，因此程序次序规则不适用；由于没有同步块，自然不会发生lock和unlock，所以管程锁定规则不适用；value变量没有定义为volatile，所以volatile变量规则也不适用；后面的其他规则和这里没有关系。也就是说，尽管线程A在操作时间上先于线程B，但是无法确定线程B中的“getValue()"方法的返回结果，因此这里的操作是不安全的。

如何修复这个问题呢？

• getter/setter方法定义为synchronized方法，这样就可以套用管程锁定规则。
• 定义value为volatile类型，这样就可以套用volatile变量规则。