Java并发编程：Volatile关键字

末蓝、 2023-02-28 04:29 2阅读 0赞

前言  
最近LZ在准备和巩固面试的东西，最近的LZ文笔风格就会比较略显老土，稍失俏皮了，还望海涵，会当博主时日得志之时，再展风骚…咳咳咳…

不扯了，今天就来写写水文，回到正题提到Volatile，在单线程环境中，我们几乎用不到Volatile，但是 **多线程** 环境中，这个关键词随处可见。

### 文章目录 ###

*   *  1、关于Volatile
     *   *   *  1. 1、Volatile如何保证可见性？
             *  1.２、Volatile不保证原子性
             *  1.３、Valatile禁止指令重排
             *  1. 4、 Volatile的使用场景
             *  1. 5、 volatile与synchronized的区别

## 1、关于Volatile ##

volatile有三个特性：**保证可见性、不保证原子性、禁止指令重排。**下面就来详细的说说这三个特性。

#### 1. 1、Volatile如何保证可见性？ ####

什么是可见性？

> 简单来说可见性就是一个线程对共享变量值的修改，能够及时被其他线程看到。

谈到可见性，又不得不说Java内存模型JMM( java memory model ) 。不在本文的概述中，这里不再叙述，等等等等，宜春是暖男来的嘛，怎么忍心让各位**靓仔、靓女**亲自出手呢，所以需要补充对JMM知识的铁汁请点击查阅：[终于有人把Java内存模型(JMM)说清楚了][Java_JMM]。对了，暖到没有？

OK，回归正题：Volatile如何保证可见性？

重点来了．．．．  
重点来了．．．．  
重点来了．．．．

为了提高处理速度，处理器不会直接和内存进行通信，而是先将系统内存的数据读到**内部缓存**（L1，L2或L３）后再进行操作，但操作完不知道何时会写到内存，这个时候volatile就开始起作用了！

对声明了Volatile的变量进行**写操作**，jvm就会向处理器发送一条**Lock前缀的指令**，将这个变量所在缓存行的数据写会系统**主内存**，但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现**缓存一 致性协议**，其中最出名的就是Intel 的**MESI协议**

> MESI协议核心思想是：当CPU写数据时，如果发现操作的变量是**共享变量**，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

不知道大家有没有想过一个问题：CPU是怎么发现缓存中缓存该变量的缓存行是无效的呢？原理则是每个处理器会通过**嗅探机制**在总线上传播的数据来检查自己缓存的值是不是**过期**了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成**无效状态**，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。**嗅探的缺点**也显而易见：由于Volatile的MESI缓存一致性协议，需要不断的从主内存**嗅探**和**CAS**不断循环，无效交互会导致总线带宽达到峰值。

所以不要大量使用Volatile，至于什么时候去使用Volatile什么时候使用锁，根据场景区分。

深入来说Volatile是通过加入**内存屏障** 、 **禁止重排序优化**来实现Volatile **保证可见性**。指令重排后面会讲到。

> 关于内存屏障：  
> 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令  
> 对volatile变量执行读操作时，会在读操作前加入一条load屏障指令

我们通常用**happen - before**(先行发生原则)，来阐述操作之间内存的可见性。也就是前一个的操作结果对后一个操作可见，那么这两个操作就存在 happen - before 规则。两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个 操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一 个操作按顺序排在第二个操作之前，因为jvm会对代码进行编译优化，指令会出现重排序的情况，为了避免编译优化对并发编程安全性的影响，需要**happens-before规则**定义一些**禁止编译优化**的场景，保证并发编程的正确性。

#### 1.２、Volatile不保证原子性 ####

什么叫原子性？

> 所谓原子性，就是说一个操作不可被分割或加塞，要么全部执行，要么全不执行。

java程序在运行时，JVM将java文件编译成了class文件。我们使用javap命令对class文件进行反汇编，就可以查看到java编译器生成的字节码。关于原子性最常见的就是 **i++** 问题，其实 i++反汇编后是分三步进行的。

第一步：将i的初始值装载进工作内存；  
第二步：在自己的工资内存中进行自增操作；  
第三步：将自己工作内存的值刷回到主内存。

我们知道线程的执行具有随机性，假设现在i的初始值为0，有A和B两个线程对其进行++操作。首先两个线程将0拷贝到自己工作内存，当线程A在自己工作内存中进行了自增变成了1，还没来得及把1刷回到主内存，这是B线程抢到CPU执行权了。B将自己工作内存中的0进行自增，也变成了1。然后线程A将1刷回主内存，主内存此时变成了1，然后B也将1刷回主内存，主内存中的值还是1。本来A和B都对i进行了一次自增，此时主内存中的值应该是2，而结果是1，出现了写丢失的情况。这是因为i++本应该是一个原子操作，但是却被加塞了其他操作。所以说Volatile不保证原子性。

当然，也有对应的**解决方法**

> 第一种：可以用**Synchronized**  
> 第二种：使用原子**Atomic**包下的类，比如AtomicInteger

第一种办法不太好，因为synchronized太重量级了。  
第二种办法更好。为什么Atomic包就可以保证原子性呢？因为它使用了CAS算法。CAS实际上是利用处理器提供的CMPXCHG指令实现的，而处理器执行CMPXCHG指令是一个原子性操作。

#### 1.３、Valatile禁止指令重排 ####

什么是指令重排？  
在多线程情况下，计算机为了提高执行效率，就会对这些步骤进行重排序，这就叫指令重排。如果还不够通俗，那么请看这四条语句：

int x = 1;　　／／１
    int y = 2;　　／／２
    x = x + 3;　　／／３
    y = x - 4;　　／／４

正常执行顺序是从上往下1234这样执行，x的结果应该是4，y的结果应该是0。  
多线程环境中编译器指令重排后执行顺序可能就变成了1243，这样得出的x就是4，y就是-3.  
这结果显然就不正确了。不过编译器在重排的时候也会考虑**数据的依赖性**，比如哪怕指令重排后执行顺序也不可能为2413，因为第4条语句的执行是依赖 x 的。使用**Volatile**修饰，就可以**禁止指令重排**。

> 由于上文提到volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。

实际上，volatile关键字**禁止指令重排** 有 **两层意思**：

1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

可能上面说的比较绕，举个简单的例子：

x = 1;                  //语句1
    y = 2;                  //语句2
    volatile int flag = 3;  //语句3
    x = 4;                  //语句4
    y = 5;                  //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

关于指令重排这里还得提一个概念，就是`as-if-serial`， **as-if-serial** 语义的意思是：**不管怎么重排序，（单线程） 程序的执行结果不能被改变。**，编译器、runtime和处理器都必须遵守as-if-serial语义。

#### 1. 4、 Volatile的使用场景 ####

通常来说，使用volatile必须具备以下2个条件：

> 1）对变量的写操作不依赖于当前值  
> 2）该变量没有包含在具有其他变量的不变式中

实际上，这两个条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

当然也可以这样理解，就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。那么再落实到使用场景上，经典的有如下两个场景：

> 1、一个线程写，其他线程读。【其他地方就不要乱用volatile关键字】  
> 2、还有就是DCL懒汉单例【双重检查】的synchronization代码块外的那个共享变量的指令重排序问题

这里就提一下经典的DCL版单例模式，是double check lock 的缩写，中文名叫双端检索机制。所谓双端检索，就是在加锁前和加锁后都用进行一次判断。代码如下：

public class SingletonDemo { 
        private static volatile SingletonDemo  singletonDemo = null; //加了volatile关键字修饰
        private SingletonDemo(){ 
            System.err.println("构造方法被执行");
        }
        public static SingletonDemo getInstance(){ 
            if (singletonDemo == null){            // 第一次check
                synchronized (SingletonDemo.class){ 
                    if (singletonDemo == null)    // 第二次check
                        singletonDemo = new SingletonDemo();   //特别注意这一行代码！！！！
                }
            }
            return singletonDemo;
        }
     }

我们知道new 一个对象也是分三步的：

> 1.分配对象内存空间；  
> 2.初始化对象；  
> 3.将对象指向分配的内存地址。

如果没有加Volatile关键字修饰，并且步骤二和步骤三不存在数据依赖，因此编译器优化时允许这两句颠倒顺序。当指令重拍后，多线程去访问就可能会导致还没有初始化完对象，就开始使用这个对象了，因此volatile 关键字必须加上。

#### 1. 5、 volatile与synchronized的区别 ####

> 1、volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。  
> 2、volatile保证数据的可见性，但是不保证原子性; 而synchronized是一种排他(互斥)的机制，既保证可见性，又保证原子性。  
> 4、volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。  
> 3、volatile可以看做是轻量版的synchronized，volatile不保证原子性，但是如果是对一个共享变量进行多个线程的赋值，而没有其他的操作，那么就可以用volatile来代替synchronized，因为赋值本身是有原子性的，而volatile又保证了可见性，所以就可以保证线程安全了。

参考：  
《Java并发编程的艺术》  
《Java多线程编程核心技术》  
https://www.jianshu.com/p/b05e4da39de9  
https://mp.weixin.qq.com/s/Oa3tcfAFO9IgsbE22C5TEg  
https://www.cnblogs.com/dolphin0520/p/3920373.html

[Java_JMM]: https://www.hollischuang.com/archives/2550