深入理解JVM: (六)JMM与线程(1):JAVA内存模型

一、JAVA内存模型

概念：

“JAVA内存模型”(Java Memory Model 即:JMM)，定义了一套规则，用来屏蔽JAVA程序在不同平台下运行可能出现的硬件和操作系统的内存访问差异，达到内存一致的访问效果。JMM到JDK5之后才算是真正的完善起来。

1.1主内存与工作内存

JAVA内存模型的主要目的是定义程序中的各种变量的访问规则，即关注在虚拟机中变量存储到内存和从内存中取出变量值这样的底层细节。此处的变量包括实力字段、静态字段、和构成数组对象的元素。但是不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然也就不会存在线程安全问题。
Java内存模型规定了所有变量都存储在主内存(虚拟机内存的一部分)。每条线程都还有自己的工作内存，线程中的内存保存了被该线程使用的变量的主内存副本，线程对变量的所有操作(读取、赋值等)都必须在工作内存中进行，不能直接读写主内存中的数据。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。线程、主内存、工作内存三者之间交互关系如下：这里所讲的主内存、工作内存和JAVA内存区域中的堆、栈、方法区并不是同一个层次的内存的划分，两者基本上没有任何关系，如果勉强对应，那么变量、主内存、工作内存的定义上来看，主内存主要对应JAVA堆中的对象实例数据、静态变量部分，而工作内存则对应虚拟机栈中的部分区域。

1.2内存间交互操作

关于主内存和工作内存之间具体的交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存这一类的实现细节，JAVA内存模型通过定义了8个原子操作来完成。

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

如果要把一个变量从主内存拷贝到工作内存，那就要按顺序执行read和load操作，如果要把变量从工作内存同步到主内存，就要按顺序执行store和write操作。JAVA内存模型只要求上述两个操作必须按顺序执行，但是不要求是连续执行，中间也可能穿插了其他得原子操作。

除此之外，JAVA内存模型还规定了执行上述8种原子操作时，必须满足以下几种规则：

不允许read和load、store和write操作之一单独出现（即不允许一个变量从主存读取了但是工作内存不接受，或者从工作内存发起会写了但是主存不接受的情况），以上两个操作必须按顺序执行，但没有保证必须连续执行，也就是说，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操作）。

1.3原子性、可见性、有序性

原子性：
是指一个操作或多个操作要么全部执行，且执行的过程不会被任何因素打断，要么就都不执行。
首先需要说明，处理器会自动保证基本的内存操作是原子性的。处理器保证从系统内存中读取或写入一个字节是原子的。意思是，当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。
而JAVA内存模型直接保证原子性变量操作包括read、load、assign、use、store、write这六个，我们可以大致认为，基本数量类型的访问读写都是具备原子性的，如果应用场景需要一个更大范围的原子性保证，JAVA内存模型还提供了，lock、unlock操作来满足这种需求，通过字节码指令monitorenter和monitorexit来隐式使用这两个操作，这两个字节码指令反映到JAVA代码中就是同步代码块--sysnchronized关键字，因此synchronized块之间的操作也具备原子性。
可见性：
可见性就是指当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改。JAVA内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种通过依赖主内存作为传递媒介的方式来实现可见性的，这点对于无论式普通变量或者是volatile修饰过的变量都是一样。但是普通变量和volatile变量的区别是，volatile的特殊规则，能使变量被修改后立即同步到主内存（即volatile变量的store和write的原子操作必须是连续且一起出现的），以及每次使用前从主内存刷新取值(即每次执行use的原子操作，都必须刷新工作内存中的变量值)。因此我们可以说volatile保证了多线程操作时的可见性。除了volatile能够保证可见性外，synchronized和final关键字也能保证可见性，synchronized可见性是由“对一个变量执行unlock之前，必须先把此变量同步到主内存中(store、write)”这条规则获得的。
有序性：
在了解有序性前，先来了解一下什么是重排序，重排序是对内存访问操作的一种优化，他可以在不影响单线程程序正确性的前提下进行一定的调整，进而提高程序的性能，但是对于多线程场景下，就可能产生一定的问题，但是重排序导致的问题，不是必然出现的。重排序表现在两种形式：1.编译器编译后，程序顺序和源代码顺序不一致。2.处理器执行顺序和程序不一致。
那么什么时候需要禁止指令的重排序呢？当存在多个线程同时访问一块内存时，并且重排序可能会导致逻辑错误的时候，需要禁止部分代码重排序。如以下代码所示：

public class DemoConfig {
    private int count = 1;
    private boolean flag = false;
    private volatile boolean sync = false;

    public void write1(){
        count = 10;
        flag = true;//没有volatile修饰，实际执行顺序可能是flag = true; 先执行
    }

    public void read1(){
        if(flag){
            //有些JVM打印1，有些JVM打印10，不确定
            System.out.println(count);
        }
    }

    public void write2(){
        count = 11;
        sync = true;//volatile修饰，禁止指令重排序，前面的指令不会跑到后面去，即count=11;一定会比sync=true;先执行
    }

    public void read2(){
        if(sync){
            //只打印11
            System.out.println(count);
        }
    }

    public static void main(String[] args) {
        DemoConfig config = new DemoConfig();
        new Thread(() -> config.write1()).start();
        new Thread(() -> config.read1()).start();
        new Thread(() -> config.write2()).start();
        new Thread(() -> config.read2()).start();
    }
}

JAVA语言提供了，volatile和synchronized两个关键字来保证线程之间操作的有序性。volatile关键字本身就包含了禁止指令重排序的语义，使用volatile关键字，它不允许后面的指令重排序到volatile之前，也不允许前面的指令重排序到volatile之后，这意味着volatille之前的指令操作都已经执行完成，这样便形成了“指令重排序无法越过内存屏障”的效果。而synchronized则是由“一个变量同时一个时刻只允许一条线程对其进行lock操作”这条规则来实现线程间的有序性，因为在这个规则下，线程对对象的访问是串行访问的，如以下代码所示：

public class DemoSync {

    private int count = 1;
    private boolean flag = false;
    
    public synchronized void write1(){
        count = 10;
        flag = true;
    }

    public synchronized void read1(){
        if(flag){
            System.out.println(count);
        }
    }

    public static void main(String[] args) {
        //通过设置synchronized 关键字，锁住整个方法，这样即便是count =10与flag=true 进行了重排序，
        //也不会影响线程间操作的有序性，因为经过synchronized修饰后，线程只能串行访问
        new Thread(()->new DemoSync().write1());
        new Thread(()->new DemoSync().read1());
    }
}

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

关键字volatile是JAVA虚拟机提供的最轻量级的同步机制，当一个变量被定义成volatile之后，它将具备两个特性：
第一项是保证此变量对所有线程的可见性， 可见性是指当一条线程修改了这个变量的值，新值对于其他线程是来说是可以立即得知的，即：X=1，线程A和线程B先后读取X，此时在线程A和B的工作内存里面读取的X=1，然后A线程原子性操作，先将X=1修改为2，虽然此时B工作内存的依然为1，但是假如X是经过volatile关键字修饰过的话，B线程在使用(use)X值的时候，会去刷新X值，从主内存获取最新的值，而对于没有经过volatile关键字修饰的变量，那么就无法感知到X是否被修改过了，依旧为1。
对于普通变量而言，普通变量的值在线程间传递时均需要通过主内存来完成。比如，线程A修改一个普通变量的值，然后向主内存回写，另外一条线程B在线程A回写完成后再对主内存进行读取的操作，新变量值才会对B线程可见。
但是可见性并不能保证线程一定是安全的，因为volatile修饰的变量只保证了获取值(read、load、use)或者修改值(assign、store、write)的原子性，即经过volatile修饰过后的变量原子性从最小的原子操作，上升到了3个原子操作，但是并不能保证获取值和修改值这两个操作是在同一个原子里面(即非原子性操作)，导致当出现基于volatile变量的运算在并发的情况下，是线程不安全的。
由于volatile变量只能保证可见性，在不符合以下两个规则的运算场景中，我们仍然要通过加锁来保证原子性：

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

第二项是语义禁止指令重排序， 普通的变量仅保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证赋值操作的顺序与程序代码的执行顺序一样。而经过volatile修饰的变量，不允许后面的指令重排序到volatile之前，也不允许前面的指令重排序到volatile之后。

以下为JAVA内存模型对volatile变量定义的特殊规则，定义变量V、W被volatile修饰，线程T会操作变量V和W，那么现在进行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修饰的变量不会被指令重排序优化,保证代码的执行顺序与程序的顺序相同)

1.5先行发生原则

概念:

先行发生原则(Happens-Before)是用来判断数据是否存在竞争，线程是否安全的非常重要手段，是用来定义JAVA内存模型中两项操作之间的偏序关系。举个例子来说明下什么是先行发生原则：
操作A先行发生于操作B，那么在B操作发生之前，A操作产生的“影响”都会被操作B感知到。这里的影响是指修改了内存中的共享变量、发送了消息、调用了方法等。

//以下操作在线程A执行
i = 1;
//以下操作在线程B执行
j = i;
//以下操作在线程C执行
i = 2;

假设线程A中的操作“i=1”先行发生于线程B的操作“j=i”，那么可以确定在线程B的操作执行后，变量j的值一定等于1，得出这个结论的依据有两个：一是根据先行发生原则，“i=1”的结果可以被观察到；二是线程C还没“登场”，线程A操作结束之后没有其他线程会修改变量i的值。现在再来考虑线程C，我们依然保持线程A和线程B之间的先行发生关系，而线程C出现在线程A和线程B的操作之间，但是线程C与线程B没有先行发生关系，那j的值会是多少呢？答案是不确定！1和2都有可能，因为线程C对变量i的影响可能会被线程B观察到，也可能不会，这时候线程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的结论。

赛博云记录