Java 多线程（八）Java 内存模型

什么是内存模型

假设一个线程为变量 aVariable 赋值:

aVariable = 3;

内存模型需要解决的问题是：在什么条件下，读取aVariable的线程将看到这个值为3.

首先我们要了解：

在编译器中生成的指令顺序可以与源代码中的顺序不同;此外编译器还会把变量保存在寄存器而不是内存中。
处理器可以采用乱序或并行的方式来执行指令
缓存可能会改变将写入变量提交到主内存的次序
保存在处理器本地缓存中的值，对于其他处理器是不可见的

这些因素都会使得一个线程无法看到变量的最新值。

为什么会出现这些奇怪操作？
==性能提升==；
近年来为了提升计算性能采取的方式包括：

提升时钟频率
采用流水线的超标量执行单元
动态指令调度
猜测执行
多级缓存
编译器优化
- 指令重排优化执行
- 优化全局寄存器分配算法

由于时钟频率越来越难以提高，很多厂商转而生产多核处理器，因为能提高的只有硬件并行性。

重排序的解释

在没有充分同步的程序中，如果调度器采用不恰当的方式来交替执行不同的线程操作，那么将导致不正确的结果。更糟糕的是JMM还使得不同线程看到的操作执行顺序是不同的，从而导致在缺乏同步的情况下，要推断操作的执行顺序将变得更加复杂。

Java 语言规范要求 JVM 在线程中维护一种类似串行的语义：只要程序的最终结果与在严格串行环境中执行的结果相同，就允许类似指令重排序这种操作的存在。

各种使操作延迟或者看似乱序执行的不同原因，都可以归为重排序

平台的内存模型

在内存共享的多处理器体系架构中，每个处理器都拥有自己的缓存，并且定期与主内存进行协调。
在不同的处理器架构中分别提供了不同级别的缓存一致性，其中一部分只提供最小的保证，即允许不同的处理器在任一时刻从同一个储存位置看到不同的值。
操作系统、编译器以及运行时需要弥合这种在硬件能力与线程安全需求之间的差异

确保每个处理器在任一时刻都知道其他处理器正在进行的工作将需要非常大的开销。在大多数的时间里，这种信息是不必要的，因此处理器会适当放宽储存一致性保证，以换取性能的提升。
此外还定义了一些特殊指令（内存栅栏或栅栏）,当需要共享数据时，这些指令就能实现额外的储存协调保证。

幸运的是，Java 程序不需要指定内存栅栏的位置，只需要通过正确的使用同步来访问共享数据。

Java 内存模型

Java 内存模型（JMM）是通过各种操作定义的，包括对变量的读/写操作，监视器的加锁/释放，以及线程的启动和合并操作。

`Happens-Before`规则

JMM为程序中的所有操作定义了一个偏序关系，称之为Happens-Before。要想保证执行操作 B 的线程能看到 A 的结果（无论 A 和 B 是否在同一个线程中执行），那么 A 和 B 之间必须满足Happens-Before关系。如果两个操作之间缺乏Happens-Before关系，那么JMM可以对它们任意地重排序。

程序顺序规则如果程序中操作 A 在操作 B 之前，那么在线程中 A 操作将在 B 操作前执行
监视器锁规则在监视器上的解锁操作必须在同一个监视器锁上的加锁操作之前执行（不应该是之后吗。。。。Monitor？？）
volatile变量规则对 volatile 比那里的写入操作必须在对该变量的读操作之前执行。
线程启动规则 在线程上对Thread.start()的调用必须在该线程中执行任何操作之前执行。
线程结束规则 线程中的任何操作都必须在其他线程检测到该线程已经结束之前执行，或者从 Thread.join 中成功返回，或者在调用 Thread.isAlive时返回 false
中断规则当一个线程在另一个线程上调用 interrupt 时，必须在被中断线程检测到 interrupt 调用前执行（通过抛出 InterruptException，或者调用 isInterrupted 和 interrupted）
终结器规则对象的构造函数必须在启动该对象的终结器之前执行完成
传递性如果操作 A 在操作 B 之前执行，并且操作 B 在操作 C 之前执行，那么操作 A 必须在操作 C 之前执行

我们可以通过下图给出了两个线程使用同一个锁时，在他们之间的Happens-Before关系（监视器锁规则）：

image

在线程 A 内部的所有操作都按照它们在源程序中的先后顺序来排序，在线程 B 内部的操作也是如此。由于 A 释放了锁 M，并且 B 随后获取了锁 M，因此 A 中所有在释放锁之前的操作，也就位于 B 请锁求之后的所有操作之前。

对象发布

当对象缺少Happens-Before关系时，就可能出现重排序问题，这就解释了为什么在没有充分同步的情况下发布一个对象会导致另一个线程看到一个只被部分构造的对象。另一个方面，Happens-Before排序是在内存访问级别上操作的，它是一种『并发级的汇编语言』

静态内部类实现对象发布

利用 JVM 加载机制保证线程安全：

public class InnerStaticSingleton {
    private static class SingletonHolder {
        private static final InnerStaticSingleton INSTANCE = new InnerStaticSingleton();
    }
    public static InnerStaticSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

==如果需要传参的话，该如何进行静态内部类的初始化==

DCL 双重检查加锁

确保实例化对象在有 volatile 的声明的前提下，可以达到线程安全的效果。

public class DCLInstance {
    private static volatile DCLInstance instance;
    private DCLInstance(){}
    public static DCLInstance getInstance() {
        if (instance == null){
            synchronized (DCLInstance.class){
                if (instance == null){
                    instance = new DCLInstance();
                }
            }
        }
        return instance;
    }
}

这里getInstance进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。