【JVM】JVM系列之内存模型（六）（2）

四、顺序一致性内存模型

　　顺序一致性内存模型时JMM的参考模型，它提供了很强的内存一致性与可见性，是一个被计算机科学家理想化了的理论参考模型，它为程序员提供了极强的内存可见性保证。JMM对正确同步的多线程程序的内存一致性做了如下保证

　　如果程序是正确同步的，程序的执行将具有顺序一致性（sequentially consistent）-- 即程序的执行结果与该程序在顺序一致性内存模型中的执行结果相同。马上我们将会看到，这对于程序员来说是一个极强的保证。这里的同步是指广义上的同步，包括对常用同步原语（synchronized，volatile 和 final）的正确使用。

　　顺序一致性内存模型包括如下两个特性：

　　1. 一个线程中的所有操作必须按照程序的顺序来执行。

　　2. （不管程序是否同步）所有线程都只能看到一个单一的操作执行顺序。在顺序一致性内存模型中，每个操作都必须原子执行且立刻对所有线程可见（JMM中并不保证）。

　　顺序一致性内存模型为程序员提供的视图如下：

说明：每一时刻只有一个线程可以访问内存，当多个线程并发执行时，图中的开关装置能把所有线程的所有内存读/写操作串行化（即在顺序一致性模型中，所有操作之间具有全序关系）。下面这个例子更进一步阐明了在顺序一致性内存模型中各线程操作之间的关系。

　　假设线程A有A1、A2、A3三个操作，线程B有B1、B2、B3三个操作。

　　① 若使用监视器锁来进行同步，在A的三个操作完成后，释放监视器锁，之后B获得监视器锁，那么整个操作序列为：A1 -> A2 -> A3 -> B1 -> B2 -> B3。

　　② 若不使用监视器锁来进行同步，那么整个序列可能为：A1 -> B1 -> A2 -> B2 -> B3 -> A3。其中线程A、B的三个操作是有序的，并且线程A、B看到的操作序列都是同一操作序列，每个操作都必须原子执行且立刻对所有线程可见，但是整体的操作无序。

　　未同步程序在 JMM 中不但整体的执行顺序是无序的，而且所有线程看到的操作执行顺序也可能不一致。比如，在当前线程把写过的数据缓存在本地内存中，在还没有刷新到主内存之前，这个写操作仅对当前线程可见；从其他线程的角度来观察，会认为这个写操作根本还没有被当前线程执行。只有当前线程把本地内存中写过的数据刷新到主内存之后，这个写操作才能对其他线程可见。在这种情况下，当前线程和其它线程看到的操作执行顺序将不一致，当前线程认为写数据到缓冲区就完成了写操作，其他线程认为只有数据刷新到主内存才算完成了写操作，所以就导致了线程之间看到的操作序列不相同。

　　顺序一致性内存模型是通过内存规则保证顺序一致性，顺序一致性是JMM追求的目标，但是JMM模型本身并不进行保证，必须通过适当的同步保证。

　　4.1 同步程序的执行特性

　　下面例子展示一个正确同步的程序在JMM和顺序一致性内存模型的操作序列。

class SynchronizedExample { 
    int a = 0;
    boolean flag = false;
    public synchronized void writer() { // 获取锁
        a = 1;    //操作A
        flag = true;    //操作B
    } // 释放锁
    public synchronized void reader() { // 获取锁
        if (flag) {    //操作C
            int i = a;    //操作D
        }
    } // 释放锁
}

说明：线程A先执行writer方法，线程B执行reader方法。这是一个正确同步的程序，在JMM的操作序列与在顺序一致性模型的操作序列是相同的。

说明：JMM模型中允许临界区的操作重排序（即使有控制依赖），而顺序一致性内存模型中则按照程序顺序执行。线程 A 在临界区内做了重排序，但由于监视器的互斥执行的特性，这里的线程 B 根本无法“观察”到线程 A 在临界区内的重排序。这种重排序既提高了执行效率，又没有改变程序的执行结果。同时，JMM 会在退出临界区和进入临界区这两个关键时间点做一些特别处理，使得线程在这两个时间点具有与顺序一致性模型相同的内存视图。

　　从这里我们可以看到 JMM 在具体实现上的基本方针：在不改变（正确同步的）程序执行结果的前提下，尽可能的为编译器和处理器的优化打开方便之门。

　　4.2 未同步程序的执行特性

　　对于未同步或未正确同步的多线程程序，JMM只提供最小安全性：线程执行时读取到的值，要么是之前某个线程写入的值，要么是默认值（0，null，false），JMM保证线程读操作读取到的值不会无中生有的冒出来。为了 实现最小安全性，JVM在堆上分配对象时，首先会清零内存空间，然后才会在上面分配对象（JVM内部会同步这两个操作）。因此，在已清零的内存空间分配对象时，域的默认初始化已经完成了。

　　JMM 不保证未同步程序的执行结果与该程序在顺序一致性模型中的执行结果一致。因为如果想要保证执行结果一致，JMM需要禁止大量的处理器和编译器的优化，这对程序的执行性能会产生很大的影响。而且未同步程序在顺序一致性模型中执行时，整体是无序的，其执行结果往往无法预知。保证未同步程序在这两个模型中的执行结果一致没什么意义。

　　未同步程序在 JMM 中的执行时，整体上是无序的，其执行结果无法预知。未同步程序在两个模型中的执行特性有下面几个差异：

　　① 顺序一致性模型保证单线程内的操作会按程序的顺序执行，而 JMM 不保证单线程内的操作会按程序的顺序执行（会进行重排序）。

　　② 顺序一致性模型保证所有线程只能看到一致的操作执行顺序，而 JMM 不保证所有线程能看到一致的操作执行顺序。

　　③ JMM不保证对 64 位的 long 型和 double 型变量的读/写操作具有原子性（JDK5之后的读具有原子性，写不具有），而顺序一致性模型保证对所有的内存读/写操作都具有原子性。

五、volatile型变量说明

　　关键字volatile是Java虚拟机提供的最轻量级的同步机制，当一个变量定义为volatile时，它将具备两种特性，可见性与禁止指令重排序优化。volatile通常会与synchronize关键字做对比。

　　① 可见性。当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即获得的，但是基于volatile变量的操作并不是安全的（如自增操作），下面两种情况就不太适合使用volatile，而需要使用加锁（synchronize、原子类）来保证原子性。

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

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

　　② 禁止指令重排序优化。不允许对volatile操作指令进行重排序。

　　下面是是一个volatile的例子。　

class VolatileFeaturesExample {
    volatile long vl = 0L; //使用 volatile 声明 64 位的 long 型变量
    public void set(long l) {
        vl = l;    //单个 volatile 变量的写
    }
    public void getAndIncrement () {
        vl++; //复合（多个）volatile 变量的读/写
    }
    public long get() {
        return vl; //单个 volatile 变量的读
    }
}

说明：上述使用volatile关键字的程序与下面使用synchronize关键字的程序效果等效。　

class VolatileFeaturesExample {
    long vl = 0L; // 64 位的 long 型普通变量
    public synchronized void set(long l) { //对单个的普通变量的写用同一个
        vl = l;
    }
    public void getAndIncrement () { //普通方法调用
        long temp = get(); //调用已同步的读方法 
        temp += 1L; //普通写操作
        set(temp); //调用已同步的写方法
    }
    public synchronized long get() { // 对单个的普通变量的读用同一个锁同步
        return vl;
    }
}

volatile变量的读写与锁的释放与获取相对应。读对应着锁的释放，写对应锁的获取。

　　5.1 volatile的happens - before关系

　　前面我们知道happens - before 关系是保证内存可见性的重要依据。那么在volatile变量与happens - before 之间是什么关系呢，我们通过一个示例说明　　

class VolatileExample {
    int    a = 0;
    volatile boolean flag = false;
    public void writer() {
        a = 1; //1
        flag = true; //2
    }
    public void reader() {
        if (flag) { //3
            int i =    a; //4
        }
    }
}

说明：假定线程A先执行writer方法，线程B后执行reader方法，那么根据happens - before关系，我们可以知道：

　　1. 根据程序顺序规则，1 happens before 2; 3 happens before 4。

　　2. 根据 volatile变量规则，2 happens before 3。

　　3. 根据 happens before 的传递性，1 happens before 4。

　　具体的happens - before图形化如下

说明：上述图中存在箭头表示两者之间存在happens - before关系。

　　5.2 volatile读写内存语义

　　1. 读内存语义。当读一个 volatile 变量时，JMM 会把该线程对应的本地内存置为无效。线程之后将从主内存中读取共享变量。

　　2. 写内存语义。当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。这样就保证了volatile的内存可见性。

　　volatile读写内存语义总结为如下三条：

　　1. 线程 A 写一个 volatile 变量，实质上是线程 A 向接下来将要读这个 volatile 变量的某个线程发出了（其对共享变量所在修改的）消息。

　　2. 线程 B 读一个 volatile 变量，实质上是线程 B 接收了之前某个线程发出的（在写这个 volatile 变量之前对共享变量所做修改的）消息。

　　3. 线程 A 写一个 volatile 变量，随后线程 B 读这个 volatile 变量，这个过程实质上是线程 A 通过主内存向线程 B 发送消息。