前言

已知导致可见性的原因是缓存，导致有序性的原因是编译优化，那解决可见性、有序性最直接的办法就是禁用缓存和编译优化。但是，这样问题虽然解决了，我们程序的性能可就堪忧了。
合理的方案应该是按需禁用缓存以及编译优化。而 Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。
Java 内存模型（Java Memory Model），简称 JMM，它是一种抽象的概念，并不真实存在，它描述的一组规则或规范，通过这组规范定义了程序中各个变量的访问方式。

关键字 synchronized

在 Java 中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

对于 32 位系统来说，long 类型数据和 double 类型数据，它们的读写并非原子性的，也就是说如果存在两条线程同时对 long 类型或者 double 类型的数据进行读写，是存在相互干扰的。因为对于 32 位虚拟机来说，每次原子读写是 32 位，而 long 和 double 都是 64 位的存储单元，这样会导致一个线程 A 在写时，操作完成前 32 位的原子操作后，轮到线程 B 读取时，恰好只读取来后 32 位的数据，这样可能会读取到一个即非原值又不是线程修改值的变量，它可能是“半个变量”的数值，即 64 位数据被两个线程分成了两次读取。

class X {
    
  // 修饰非静态方法
  synchronized void say() {
    // 临界区
  }
    
  // 修饰静态方法
  synchronized static void eat() {
    // 临界区
  }
    
  // 修饰代码块
  Object obj = new Object()；
  void fly() {
    synchronized(obj) {
      // 临界区
    }
  }
}  

注意：当修饰静态方法的时候，锁定的是当前类的 Class 对象，在上面的例子中就是 Class X；当修饰非静态方法的时候，锁定的是当前实例对象 this。

关键字 volatile

JVM 启动之后，操作系统会为 JVM 进程分配一定的内存空间，这部分内存空间就称为“主内存”。另外 Java 程序的所有工作都由线程来完成，而每个线程都会有一小块内存，称为“工作内存”，Java 中的线程在执行的过程中，会先将数据从主内存中复制到线程的工作内存，然后再执行计算，执行计算之后，再把计算结果刷新到“主内存”中。

这种工作内存与主内存同步延迟现象就会造成可见性问题，对此，Java 提供了关键字 volatile 来保证可见性。
关键字 volatile 的意义就是禁用 CPU 缓存。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

关键字 final

当你使用关键字 final 修饰某个类时，此类就不能被继承；修饰某个方法时，此方法可以被重载。
在 JDK 1.5 以后 Java 内存模型对 final 类型变量的重排进行了约束。只要我们提供正确构造函数没有“逸出”，就不会出问题了。

this 逸出

虽然 final 域写重排序规则可以确保我们在使用一个对象引用的时候该对象的 final 域已经在构造函数被初始化过了。但有一个前提条件的，也就是：在构造函数，不能让这个被构造的对象被其他线程可见，也就是说该对象引用不能在构造函数中“溢出”。
举个例子：在构造函数里面，变量 x 和变量 test 之间并没有数据依赖关系，它们的初始化顺序就可能被重排序：可能先初始化 test 再初始化 x。而将 this 赋值给了全局变量 test，这就是“逸出”，多线程通过 test 读取 x 是有可能读到 0 的。

public class FinalReferenceEscapeTest {

    private final int x;
    private FinalReferenceEscapeTest test;

    // 错误的构造函数
    public FinalReferenceEscapeTest() {
        x = 1;
        // 此处就是讲 this 逸出
        test = this;
    }

    public void write(){
        new FinalReferenceEscapeTest();
    }

    public void read(){
        // 线程可能读取到 test == null
        if(test != null){
            // 有可能读取到 x 为 0
            int y = test.x;
        }
    }
}

Happens-Before 原则

除了可以用关键字 synchronized 和 volatile 来保证有序性与可见性。除此之外，Java 还提供了 Happens-Before 规则。Happens-Before，直接翻译“先行发生”，但它不是说前面一个操作发生在后续操作的前面，它真正要表达的是：前面一个操作的结果对后续操作是可见的。

程序的顺序性规则

这条规则是指在一个线程中，按照程序顺序，前面的操作 Happens-Before 于后续的任意操作。

public class Example {
    int x = 0;
    /**
     * 告诉编译器，对这个变量的读写，不能使用 CPU 缓存，必须从内存中读取或者写入
     */
    volatile boolean v = false;

    public void writer() {
        x = 42;
        // 更新 v 为 true
        v = true;
    }

    public void reader() {
        if (v == true) {
            System.out.println("此时的 x 为：" + x);
        }
    }
}

按照程序的顺序，第 9 行代码 “x = 42;” Happens-Before 于第 11 行代码 “v = true;”，这比较符合单线程里面的思维：程序前面对某个变量的修改一定是对后续操作可见的。
在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。准确地说，应该是控制流顺序而不是程序代码顺序，因为要考虑分支、循环等结构。

volatile 变量规则

这条规则是指对一个 volatile 变量的写操作， Happens-Before 于后续对这个 volatile 变量的读操作。

管程中锁定规则

这条规则是指对一个锁的解锁 Happens-Before 于后续对这个锁的加锁。一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。这里必须强调的是同一个锁，而"后面"是指时间上的先后顺序。
关键字 synchronized 是 Java 语言对管程的实现。管程中的锁在 Java 里是隐式实现的，例如下面的代码，在进入同步块之前，会自动加锁，而在代码块执行完会自动释放锁，加锁以及释放锁都是编译器帮我们实现的。

synchronized (this) { //此处自动加锁
  // x 是共享变量,初始值为 10
  if (this.x < 2021) {
    this.x = 2021; 
  }  
} //此处自动解锁

假设 x 的初始值是 10，线程 A 执行完代码块后 x 的值会变成 2021（执行完自动释放锁），线程 B 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x==2021。

线程的启动规则

它是指主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作。换句话说就是，如果线程 A 调用线程 B 的 start() 方法（即在线程 A 中启动线程 B），那么该 start() 操作 Happens-Before 于线程 B 中的任意操作。

Thread B = new Thread(()->{
  // 主线程调用 B.start()之前
  // 所有对共享变量的修改，此处皆可见
  // 此例中，num==2233
});
// 此处对共享变量 num 修改
num = 2233;
// 主线程启动子线程
B.start();

线程的等待规则

这条是关于线程等待的。它是指主线程 A 等待子线程 B 完成（主线程 A 通过调用子线程 B 的 join() 方法实现），当子线程 B 完成后（主线程 A 中 join() 方法返回），主线程能够看到子线程的操作。当然所谓的“看到”，指的是对共享变量的操作。
换句话说就是，如果在线程 A 中，调用线程 B 的 join() 并成功返回，那么线程 B 中的任意操作 Happens-Before 于该 join() 操作的返回。

Thread B = new Thread(()->{
  // 此处对共享变量var修改
  var = 66;
});
// 例如此处对共享变量修改，
// 则这个修改结果对线程B可见
// 主线程启动子线程
B.start();
B.join()
// 子线程所有对共享变量的修改
// 在主线程调用 B.join() 之后皆可见
// 此例中，var==66

线程的中断规则

对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 Thread.interrupted() 方法检测到是否有中断发生。

对象的终结规则

一个对象的初始化完成(构造函数执行结束)先行发生于它的 finalize() 方法的开始。

传递性规则

这条规则是指如果 A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C。就如同 10 > 9 且 9 > 8，那么 10 > 8。

参考

知乎专栏 - Java内存模型（JMM）总结
Java 全栈知识体系 - Java内存模型详解