Java多线程的原子性、可见性、有序性_多线程的原子性可见性有序性

1.Java内存模型

​ Java虚拟机规范试图定义一种Java内存模型（JMM）,来屏蔽掉各种硬件和操作系统的内存访问差异，让Java程序在各种平台上都能达到一致的内存访问效果。简单来说，由于CPU执行指令的速度是很快的，但是内存访问的速度就慢了很多，相差的不是一个数量级，所以搞处理器的那群大佬们又在CPU里加了好几层高速缓存。

​ 在Java内存模型里，对上述的优化又进行了一波抽象。JMM规定所有变量都是存在主存中的，类似于上面提到的普通内存，每个线程又包含自己的工作内存，方便理解就可以看成CPU上的寄存器或者高速缓存。所以线程的操作都是以工作内存为主，它们只能访问自己的工作内存，且工作前后都要把值在同步回主内存。

​ 拿张纸画一下：

​ 在线程执行时，首先会从主存中read变量值，再load到工作内存中的副本中，然后再传给处理器执行，执行完毕后再给工作内存中的副本赋值，随后工作内存再把值传回给主存，主存中的值才更新。

​ 使用工作内存和主存，虽然加快的速度，但是也带来了一些问题。比如看下面一个例子：

i = i + 1;
1

​ 假设 i 初值为0，当只有一个线程执行它时，结果肯定得到1，当两个线程执行时，会得到结果2吗？这倒不一定了。可能存在这种情况：

线程1： load i from 主存 // i = 0
i + 1 // i = 1
线程2： load i from主存 // 因为线程1还没将i的值写回主存，所以i还是0
i + 1 //i = 1
线程1: save i to 主存
线程2： save i to 主存
1
2
3
4
5
6

​ 如果两个线程按照上面的执行流程，那么i最后的值居然是1了。如果最后的写回生效的慢，你再读取i的值，都可能是0，这就是缓存不一致问题。

​ JMM主要就是围绕着如何在并发过程中如何处理原子性、可见性和有序性这3个特征来建立的，通过解决这三个问题，可以解除缓存不一致的问题。而volatile跟可见性和有序性都有关。

2.原子性

​ Java中，对基本数据类型的读取和赋值操作是原子性操作，所谓原子性操作就是指这些操作是不可中断的，要做一定做完，要么就没有执行。比如：

i = 2;
j = i;
i++;
i = i + 1；
1
2
3
4

​ 上面4个操作中，i=2是读取操作，必定是原子性操作，j=i你以为是原子性操作，其实吧，分为两步，一是读取i的值，然后再赋值给j,这就是2步操作了，称不上原子操作，i++和i = i + 1其实是等效的，读取i的值，加1，再写回主存，那就是3步操作了。所以上面的举例中，最后的值可能出现多种情况，就是因为满足不了原子性。

​ 这么说来，只有简单的读取，赋值是原子操作，还只能是用数字赋值，用变量的话还多了一步读取变量值的操作。有个例外是，虚拟机规范中允许对64位数据类型(long和double)，分为2次32为的操作来处理，但是最新JDK实现还是实现了原子操作的。

​ JMM只实现了基本的原子性，像上面i++那样的操作，必须借助于synchronized和Lock来保证整块代码的原子性了。线程在释放锁之前，必然会把i的值刷回到主存的。

3.可见性

​ 说到可见性，Java就是利用volatile来提供可见性的。

​ 当一个变量被volatile修饰时，那么对它的修改会立刻刷新到主存，当其它线程需要读取该变量时，会去内存中读取新值。而普通变量则不能保证这一点。

​ 其实通过synchronized和Lock也能够保证可见性，线程在释放锁之前，会把共享变量值都刷回主存，但是synchronized和Lock的开销都更大。

4.有序性

​ JMM是允许编译器和处理器对指令重排序的，但是规定了as-if-serial语义，即不管怎么重排序，程序的执行结果不能改变。比如下面的程序段：

double pi = 3.14; //A
double r = 1; //B
double s= pi * r * r;//C
1
2
3

​ 上面的语句，可以按照A->B->C执行，结果为3.14,但是也可以按照B->A->C的顺序执行，因为A、B是两句独立的语句，而C则依赖于A、B，所以A、B可以重排序，但是C却不能排到A、B的前面。JMM保证了重排序不会影响到单线程的执行，但是在多线程中却容易出问题。

​ 比如这样的代码:

int a = 0;
bool flag = false;

public void write() {
    a = 2; //1
    flag = true; //2
}

public void multiply() {
    if (flag) { //3
    int ret = a * a;//4
}
1
2
3
4
5
6
7
8
9
10
11
12

​ 假如有两个线程执行上述代码段，线程1先执行write，随后线程2再执行multiply，最后ret的值一定是4吗？结果不一定：

​ 如图所示，write方法里的1和2做了重排序，线程1先对flag赋值为true，随后执行到线程2，ret直接计算出结果，再到线程1，这时候a才赋值为2,很明显迟了一步。

​ 这时候可以为flag加上volatile关键字，禁止重排序，可以确保程序的“有序性”，也可以上重量级的synchronized和Lock来保证有序性,它们能保证那一块区域里的代码都是一次性执行完毕的。

5.Happen Before 规则

​ JMM具备一些先天的有序性,即不需要通过任何手段就可以保证的有序性，通常称为happen-before原则。<<JSR-133：Java Memory Model and Thread Specification>>定义了如下happen-before规则：

1. 程序顺序规则： 一个线程内保证语义的串行行；

2. 监视器锁规则：对一个线程的解锁，先于随后对这个线程的加锁；

3. volatile变量规则： 对一个volatile域的写，先于后续对这个volatile域的读；

4. 传递性：如果A 先于 B ,且 B 先于 C, 那么 A 先于 C；

5. start()规则： 线程的start()方法先于它的每一个操作；

6. join()原则： 线程的join()方法先于join()后的每一个操作；

7. interrupt()原则： 线程的中断（interrupt()）先于被中断线程的代码；

8. finalize()原则：对象的构造函数执行、结束先于finalize()方法。
   
   
   
   
   
   
   
   
   参考：点击跳转，文章略有改动。