前言

上一篇我们介绍了在并发编程里面导致bug的三种问题，可见性问题，原子性问题，有序性问题。针对这三个问题，Java语言提供了Java内存模型（JMM）来解决这三种问题，主要是针对有序性和可见性问题。其本质上就是按需禁用缓存和编译优化。接下来我们就详细的阐述下。

Java内存模型介绍

Java 内存模型是一个很复杂的规范，本质上可以理解为：Java内存模型规范了JVM如何提供按需禁用缓存和编译优化（本质上是指令重排序）的方法。具体来说，这些方法包括：通过volatile,synchronized,final 还有Happen-Before规则来控制。下面我就详细介绍下。

Happen-Before 的本质上表示的意思是，先行发生，本质上表示的意思是 前面的操作产生的结果对后续操作可见。例如：A先行发生于B，那么执行B操作时，A操作产生的数据B操作一定能看到。

程序次序规则

程序次序规则：程序前面对某个变量的修改对后续操作一定是可见的

例如：

 public void writer() {
        a = 43;
        b = a;
    }

执行b=a时，a=43 一定是可见的。

volatile

volatile 关键字修饰的变量，表示这个变量的值变更对其他线程是可见的。例如：

volatile int y=1,它表达的意思是对这个变量的读写，不能使用CPU缓存，必须从内存中直接读写。

如下程序所示：

   private volatile  boolean flag = false;
    private   int a = 0;

    public void writer() {
        a = 43;
        flag = true;
    }
    public void read() {
        if (flag) {
            System.out.println("读取到的a值是="+a);
        }
    }

在Java 1.5之后的版本中，读取到的a 值永远都是43。

故：volatile变量的规则是：volatile变量的写操作对于这个volatile变得的读操作是可见的

管程（synchronized）

管程锁定规则：管程中对一个锁的解锁先行发生于对这个锁的加锁操作

我们来看一个用synchronized修饰的方法。

   synchronized int getValue() {
        return value;
    }

如上程序，假设有线程A和线程B, 线程A 首先获取到锁，进入getValue() 方法，那么只有当线程A释放锁之后线程B才有可能获取到锁。

传递性

A先行发生于B，B先行发生于C，那么A必然先行发生于C

    public void transfer() {
        c = a + b;  //1
        a = 100;  //2
        c = a - b;//3
    }

如上程序 第一步一定优先发生于第二步，第二步一定优先于第三步。那么第一步一定先于第三步发生。

线程启动规则

线程启动规则：线程的start()方法先行发生于此线程的每一个操作

这个很好理解：就是线程只有调用了start()方法变成了 可运行状态，才会执行线程需要处理的任务。

例如：

  new Thread(new Runnable() {
            public void run() {
                longTest.countTest();
            }
        }).start();

线程里需要执行的​​longTest.countTest();​​方法一定是在start() 方法执行之后才会执行。

线程终止规则

线程终止规则：线程的join()规则，线程中所有的操作都先行发生于此线程的终止操作

也就是说调用线程的join()方法时，线程所执行的任务产生的结果一定是对 join()方法可见的。

例如：

 final LongTest longTest = new LongTest();
        Thread threadA = new Thread(new Runnable() {
            public void run() {
                longTest.countTest();
            }
        });
        Thread threadB = new Thread(new Runnable() {
            public void run() {
                longTest.countTest();
            }
        });
        threadA.start(); //1
        threadA.join();  //2
        threadB.start(); //3
        threadB.join(); //4

如上程序所示：第二步调用threadA.join();方法之后，线程A 计算所得到的值，对第三步一定是可见的。因为调用 threadA.join();之后线程A就被终止了。

在程序里我们可以通过 Thread.isAlive() 的返回值检测线程是否终止执行。

线程中断规则

线程中断规则：对线程interrupt()方法的调用先行发生于被中断的线程代码检测到中断事件的发生

也就是说：对线程的中断操作，对后续操作检测中断事件的操作一定是可见的。

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread("线程A");
        threadA.start();
        threadA.interrupt();
        System.out.println("线程A是否终止"+threadA.isInterrupted());
    }

如上程序：输出的结果永远都是 线程A是否终止true。这样正验证了我们前面提到的规则。

对象终结规则

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

在Java中finalize()方法我们用的比较少。再次不详细展开说明。

final

用final 修饰的变量的表示初始化完成之后就不能修改。

  1. final修饰的基本类型的变量，则其数值一旦在初始化之后便不能更改。

  2. final修饰的引用类型的变量, 则在对其初始化之后便不能再让其指向另一个对象。

  3. final 修饰的类不能被继承，类中的方法不能被重写。

  4. final 修饰的方法，不能被重写。
    在多线程环境下可以利用其不变性

总结

本文主要介绍了 Java内存模型是如何通过一系列的规则来对并发编程中的可见性问题，有序性问题进行控制的。本质上还是 按需禁用缓存和编译器优化。