【5】彻底理解volatile

发表于 | 分类于 |

2020-4-10 15:11:17开始整理文章
声明：变量的储存单元可参考传值,传引用

简介

通过之前的学习,我们了解到synchronized是阻塞式同步，在线程竞争激烈的情况下会升级为重量级锁。
而volatile就可以说是java虚拟机提供的最轻量级的同步机制。
但它同时不容易被正确理解，也至于在并发编程中很多程序员遇到线程安全的问题就会使用synchronized。

Java内存模型告诉我们，各个线程会将共享变量从主内存中拷贝到工作内存，然后执行引擎会基于工作内存中的数据进行操作处理。

线程在工作内存进行操作后何时会写到主内存中？
这个时机对普通变量是没有规定的，而针对volatile修饰的变量给java虚拟机特殊的约定，
线程对volatile变量的修改会立刻被其他线程所感知，即不会出现数据脏读的现象，从而保证数据的“可见性”。

现在我们有了一个大概的印象就是：被volatile修饰的变量能够保证每个线程能够获取该变量的最新值，从而避免出现数据脏读的现象。

原理

volatile是怎样实现了？比如一个很简单的Java代码：

1
instance = new Instancce() //instance是volatile变量

在生成汇编代码时会在volatile修饰的共享变量进行写操作的时候会多出Lock前缀的指令
我们想这个Lock指令肯定有神奇的地方，那么Lock前缀的指令在多核处理器下会发现什么事情了？
主要有这两个方面的影响：

  1. 将当前处理器缓存行的数据写回系统内存；
  2. 这个写回内存的操作会使得其他CPU里缓存了该内存地址的数据无效

为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。
如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。
但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。

所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了,
当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。
因此，经过分析我们可以得出如下结论：

  1. Lock前缀的指令会引起处理器缓存写回内存；
  2. 一个处理器的缓存回写到内存会导致其他处理器的缓存失效；
  3. 当处理器发现本地缓存失效后，就会从内存中重读该变量数据，即可以获取当前最新值。

这样针对volatile变量通过这样的机制就使得每个线程都能获得该变量的最新值。

happens-before关系

经过上面的分析，我们已经知道了volatile变量可以通过缓存一致性协议保证每个线程都能获得最新值，即满足数据的“可见性”。
我一直将并发分析的切入点分为两个核心，三大性质。

1
2
3
4
5
6
7
8
两个核心
   1. JMM(Java内存模型)包括:主内存(系统内存)和工作内存(线程内存)
   2. happens-before

三大性质
   1. 原子性
   2. 可见性
   3. 有序性

（关于三大性质的总结在以后得文章会和大家共同探讨）
废话不多说，先来看两个核心之一：volatile的happens-before关系。

在happens-before规则中有一条volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。
下面我们结合具体的代码，我们利用这条规则推导下：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class VolatileExample {
    private int a = 0;
    private volatile boolean flag = false;
    public void writer(){
        a = 1;          //1
        flag = true;   //2
    }
    public void reader(){
        if(flag){      //3
            int i = a; //4
        }
    }
}

上面的实例代码对应的happens-before关系如下图所示：
在这里插入图片描述
加锁线程A先执行writer方法，然后线程B执行reader方法,图中每一个箭头两个节点就代码一个happens-before关系，
黑色的代表根据程序顺序规则推导出来
红色的是根据volatile变量的写happens-before 于任意后续对volatile变量的读
蓝色的就是根据传递性规则推导出来的

这里的2 happen-before 3，同样根据happens-before规则定义:
【如果A happens-before B,则A的执行结果对B可见，并且A的执行顺序先于B的执行顺序】
我们可以知道操作2执行结果对操作3来说是可见的，也就是说当线程A将volatile变量 flag更改为true后线程B就能够迅速感知。

内存语义

还是按照两个核心的分析方式，分析完happens-before关系后我们现在就来进一步分析volatile的内存语义。

还是以上面的代码为例，假设线程A先执行writer方法，线程B随后执行reader方法，初始时线程的本地内存中flag和a都是初始状态，
下图是线程A执行volatile写后的状态图。
在这里插入图片描述

当volatile变量写后，线程中本地内存中共享变量就会置为失效的状态，因此线程B再需要读取从主内存中去读取该变量的最新值。
下图就展示了线程B读取同一个volatile变量的内存变化示意图。
在这里插入图片描述

从另外一个角度来看,线程A和线程B之间进行了一次通信，线程A在写volatile变量时，
实际上就像是给B发送了一个消息告诉线程B你现在的值都是旧的了，然后线程B读这个volatile变量时就像是接收了线程A刚刚发送的消息。
既然是旧的了，那线程B该怎么办了？自然而然就只能去主内存去取啦。

好的，我们现在两个核心：happens-before以及内存语义现在已经都了解清楚了。
是不是还不过瘾，突然发现原来自己会这么爱学习（微笑脸），那我们下面就再来一点干货—-volatile内存语义的实现。

内存语义的实现

我们都知道，为了性能优化，JMM在不改变正确语义的前提下，会允许编译器和处理器对指令序列进行重排序，
那如果想阻止重排序要怎么办了？答案是可以添加内存屏障。

内存屏障

JMM内存屏障分为四类见下图，
Store写：将处理器缓存的数据刷新到内存中。(工作内存新值写入到主内存)
Load读：将内存存储的数据拷贝到处理器的缓存中。(工作内存中读取主内存的数据)
在这里插入图片描述
java编译器会在生成指令系列时在适当的位置会插入内存屏障指令来禁止特定类型的处理器重排序。
为了实现volatile的内存语义，JMM会限制特定类型的编译器和处理器重排序，JMM会针对编译器制定volatile重排序规则表：
在这里插入图片描述
“NO”表示禁止重排序。
为了实现volatile内存语义时，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。
对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎是不可能的，为此，JMM采取了保守策略：

  1. 在每个volatile写操作的前面插入一个StoreStore屏障
  2. 在每个volatile写操作的后面插入一个StoreLoad屏障
  3. 在每个volatile读操作的后面插入一个LoadLoad屏障
  4. 在每个volatile读操作的后面插入一个LoadStore屏障

需要注意的是：volatile写操作是在前后分别插入内存屏障，而volatile读操作是在后面插入两个内存屏障
StoreStore屏障禁止上面的普通写和下面的volatile写重排序；
StoreLoad屏障防止上面的volatile写与下面可能有的volatile读/写重排序
LoadLoad屏障禁止下面所有的普通读操作和上面的volatile读重排序
LoadStore屏障禁止下面所有的普通写操作和上面的volatile读重排序

下面以示意图进行理解，图片摘自相当好的一本书《java并发编程的艺术》。
在这里插入图片描述

可见性分析

声明：以下为个人理解

我看到网上有一个人问了一个问题：volatile是否能保证数组中元素的可见性？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
问
    一个线程向volatile的数组中设置值，而另一个线程向volatile的数组中读取。
    比如seg.setValue(2)，随后另一个线程调用seg.getValue(2)，前一个线程设置的值对读取的线程是可见的吗？

public class Seg {

    private volatile Object[] tabs = new Object[10];

    public void setValue(int index) {
        tabs[index] = new Object();
    }

    public Object getValue(int index) {
        return tabs[index];
    }
}

首先，这个说法就有问题，他根本不了解volatile是保证了怎样的可见性。下面我们来分析。

①你要明白，工作内存中读取主内存的数据，这个数据是变量，而变量类型分为基本类型和引用类型。可参考Java数据类型
你要明白变量的含义是什么，变量有一个储存单元，里面用来存放值。而基本类型变量和引用类型变量储存单元中储存的值是不同的。
基本类型变量储存单元里面存放的是基本类型的数据。
例如int a = 123;此时变量a的储存单元中存放的是123。
而每个线程都对应着一个线程栈，方法和方法定义的局部变量和方法参数是放在栈中的。可参考多线程内存图
引用类型变量储存单元里面存放的是引用对象的地址值，而对象是属于堆内存的。
例如Student student = new Student();此时变量student的储存单元中存放的是new Student()这个对象在堆内存中的地址值。
②而volatile是修饰变量的，如果你改变了变量储存单元中的值，那么对其他线程就是可见的。
对于上面它提出的这个代码中，tabs还有引用那个数组对象，只是你改变了这个对象在堆内存中的数据，而没有改变tabs的变量。
所以，其他线程中保存的变量中的储存单元中的地址没有变，根据这个引用地址还是可以找到这个堆内存中的对象，从而拿到对象。
如果，你改变的是tabs的引用地址，例如tabs = new Object[20];那么，此时其他线程中的这个变量就会失效，从而从新获取引用地址。实现可见性。
③所以，在DCL（Double Check Lock双重检验锁）中要加volatile，从而实现先把对象的引用地址值赋值到volatile修饰的变量的储存单元中，从而实现不会出现空引用的情况。