Java基础学习之并发篇：可见性和有序性

我们知道并发中有三个重要的问题要处理：原子性、可见性和有序性。CAS保证原子性，volatile解决可见性，而happens-before原则保证有序性。本章节我们一起来学习下Java并发编程中的可见性和有序性相关知识点。

学习目标：

1. 如何解释内存不一致
2. 什么是happens-before关系
3. 为什么设计volatile
4. volatile关键字原理
5. volatile性能如何

---

内存一致性模型

在理想化情况下，我们期望顺序一致性模型中保证单线程操作会按照程序顺序执行，且保证所有线程看到的操作执行顺序一致，但在JVM中并不能保证。

我们知道不同观测者，即不同线程对历史的理解也许是不一致的。比如在某个时刻线程1和线程2观察内存，图中线程2认为是在版本3写操作已发送，而线程1认为没有发生。因此线程1和线程2产生了分歧，我们称为不一致

而我们希望在任意时刻观察到的历史是一致的，这就是有序性。而对于强一致(Sequential Consistency)：即线性一致，任何时刻都是一致的，这种肯定不现实。我们一般追求的是弱一致性(Weak Consistency)：即部分时刻一致。便需要通过借助锁、信号量、happens-before关系和volatile等同步元语来实现。
先来看一个例子：

    Runnable r1 = () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a = 10000;
            System.out.println("set a");
        };

        Runnable r2 = () -> {
            while(a < 100) {

            }

            System.out.println("end:" + a);
        };

        new Thread(r1).start();
        new Thread(r2).start();

两个线程对上面代码进行访问时，发现r2一直在循环，并没有输出end。我们通过分析发现是CPU缓存的问题。

CPU中每个核心都会自己的多级缓存，这种分级缓冲策略设计是把一些数据放在缓冲中，其速度比内存快10-100倍。然而会出现的问题就是数据更改后缓冲若不能及时更新，就会造成数据的不一致。其更新策略如下图所示：

相同CPU核心更新缓存后，再更新内存。①完成后不同核的线程只能从L3缓存获取更新，读取的值此时还未更新。
甚至会出现更严重的情况：指令重排，即没有产生有序的指令。

if(a==0){
// some code
}
return a;

并发环境下，CPU重排指令，优先将读取缓存数据进行计算。那么这里会出现读取缓存此时a=0,然后a又被重新赋值返回a=1；
综上出现内存不一致主要原因是缓存机制和指令重排。而解决这种不一致，或者说解决可见性和有序性我们可以尝试用volatile解决。

volatile

针对上面的代码

 static int a = 0;
  		Runnable r1 = () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            a = 10000;
            System.out.println("set a");
        };

        Runnable r2 = () -> {
            while(a < 100) {

            }

            System.out.println("end:" + a);
        };

        new Thread(r1).start();
        new Thread(r2).start();

那么我们可以这样解决，添加关键字volatile，输出成功。

 volatile static int a = 0;

"C:\Program Files\Java\jdk1.8.0_211\bin\java.exe" "-
set a
end:10000

Process finished with exit code 0

因此volatile实现了：

1. 对volatile变量的读，写不会被重排对他后续的读写之后，
2. 保证写的值能够马上刷新
3. 能够读取最新版本的值

在 1.5 版本，Java 内存模型对 volatile 的语义进行了增强，其中一项就是我们要说的 Happens-Before 规则，即a = 10000 happens-before a<100

happens-before规则

happens-before定义的是如果事件A应该在事件B之前发生，那么观察到的结果也是如此

在Java中，有以下遵循happens-before规则的程序：

规则	描述
线程启动	主线程 A 对子线程B start()启动 后，子线程 B 能够看到主线程在启动子线程之前的操作
线程中断	对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
线程终结	主线程 A 通过调用子线程 B 的 join() 方法实现，能看到子线程对于共享变量的操作
对象终结	一个对象的初始化完成先行于它的finalize(()方法的开始
锁的规则	对一个锁的解锁 Happens-Before 于后续对于这个锁的加锁。
传递规则	A Happens-Before 于 B，B Happens-Before 于 C，那么 A Happens-Before 于 C
volatile变量规则	对一个变量的写操作先行发生于后面对这个变量的读操作