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

说明：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 发送消息。

　　5.3 volatile内存语义的实现

　　前面讲到，volatile变量会禁止编译器、处理器重排序。下面是volatile具体的排序规则表

说明：从图中可以知道当第一个操作为volatile读时，无论第二个操作为何种操作，都不允许重排序；当第二个操作为volatile写时，无论第一个操作为何种操作，都不允许重排序；当第一个操作为volatile写时，第二个操作为volatile读时，不允许重排序。

　　为了实现 volatile 的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎不可能，为此，JMM 采取保守策略。下面是基于保守策略的 JMM 内存屏障插入策略：

　　1. 在每个 volatile 写操作的前面插入一个 StoreStore 屏障。

　　2. 在每个 volatile 写操作的后面插入一个 StoreLoad 屏障（对volatile写、普通读写实现为不允许重排序，可能会影响性能）。

　　3. 在每个 volatile 读操作的后面插入一个 LoadLoad 屏障。

　　4. 在每个 volatile 读操作的后面插入一个 LoadStore 屏障（普通读写、volatile读实现为不允许重排序，可能会影响性能）。

　　下面通过一个示例展示volatile的内存语义。　

复制代码
class VolatileBarrierExample { 
    int a;
    volatile int v1 = 1;
    volatile int v2 = 2;
    void readAndWrite() {
        int i = v1;    // 第一个 volatile 读
        int j = v2; // 第二个 volatile 读
        a = i + j; // 普通写
        v1 = i + 1; // 第一个 volatile 写
        v2 = j * 2; // 第二个 volatile 写
    }
}

　 　　根据程序，最后的指令序列如下图所示

说明：编译器、处理器会根据上下文进行优化，并不是完全按照保守策略进行插入相应的屏障指令。

六、锁

　　锁是Java并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。

　　6.1 锁的happens - before 关系

　　下面一个示例展示了锁的使用

复制代码
class MonitorExample {
    int a = 0;
    public synchronized void writer() {    // 1 
        a++; // 2
    } // 3
    public synchronized void reader() { // 4 
        int i = a; // 5
    } // 6
}

说明：假设线程 A 执行 writer()方法，随后线程 B 执行 reader()方法。该程序的happens - before关系如下：

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

　　2. 根据监视器锁规则，3 happens before 4。

　　3. 根据传递性，2 happens before 5。

　　图形化表示如下：

　6.2 锁释放获取的内存语义

　　1. 当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中，以确保之后的线程可以获取到最新的值。

　　2. 当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。

　　锁释放与获取总结为如下三条

　　1. 线程 A 释放一个锁，实质上是线程 A 向接下来将要获取这个锁的某个线程发出 了（线程 A 对共享变量所做修改的）消息。

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

　　3. 线程 A 释放锁，随后线程 B 获取这个锁，这个过程实质上是线程 A 通过主内存 向线程 B 发送消息。

　　6.3 锁内存语义的实现

　　锁的内存语义的具体实现借助了volatile变量的内存语义的实现。