Java并发编程（二）---Java内存模型

前言

上一篇我们介绍了在并发编程里面导致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; }

  

 

  
1
  
2
  
3
  
4
 

执行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); } }

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
 

在Java 1.5之后的版本中，读取到的a 值永远都是43。
故：volatile变量的规则是：volatile变量的写操作对于这个volatile变得的读操作是可见的

管程（synchronized）

管程锁定规则：管程中对一个锁的解锁先行发生于对这个锁的加锁操作
我们来看一个用synchronized修饰的方法。

   synchronized int getValue() { return value; }

  

 

  
1
  
2
  
3
 

如上程序，假设有线程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 }

  

 

  
1
  
2
  
3
  
4
  
5
 

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

线程启动规则

线程启动规则：线程的start()方法先行发生于此线程的每一个操作
这个很好理解：就是线程只有调用了start()方法变成了 可运行状态，才会执行线程需要处理的任务。
例如：

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

  

 

  
1
  
2
  
3
  
4
  
5
 

线程里需要执行的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

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
 

如上程序所示：第二步调用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()); }

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

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

对象终结规则

对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始
在Java中finalize()方法我们用的比较少。再次不详细展开说明。

final

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

1. final修饰的基本类型的变量，则其数值一旦在初始化之后便不能更改。
2. final修饰的引用类型的变量, 则在对其初始化之后便不能再让其指向另一个对象。
3. final 修饰的类不能被继承，类中的方法不能被重写。
4. final 修饰的方法，不能被重写。
   在多线程环境下可以利用其不变性

总结

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

文章来源: feige.blog.csdn.net，作者：码农飞哥，版权归原作者所有，如需转载，请联系作者。

原文链接：feige.blog.csdn.net/article/details/102801894