前言

上一篇我们介绍了在并发编程里面导致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内存模型是如何通过一系列的规则来对并发编程中的可见性问题,有序性问题进行控制的。本质上还是 按需禁用缓存和编译器优化。