【并发编程】volatile 实现原理

淡淡的烟草味﹌ 2022-03-20 09:29 281阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-concurrent）

# 一 volatile 概述 #

volatile 是轻量级的 synchronized，在多处理器开发中保证共享变量的“可见性”以及“禁止

内存重排序”。volatile 共享变量不会引起线程上下文的切换和调度，在适合的场景下拥有

更低的执行成本和更高的效率。

## 1、可见性 ##

当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。即 volatile 变量不会

被缓存在寄存器或者对其他处理器不可见的地方，因此，我们每次在读取共享变量的时候都会

读取最新写入的值。

## 2、禁止指令重排序 ##

编译器和处理器不会对 volatile 修饰的代码进行指令重排序。

# 二 实现原理 #

## 1、CPU 缓存 ##

CPU 缓存的出现主要是为了解决 **CPU 运算速度与内存读写速度不匹配**的矛盾，因为 CPU

运算速度要比内存读写速度快得多，导致 CPU 可能会花费很长时间等待数据到来或把数据写

入内存。现在 CPU 大多数情况下读写都不会直接访问内存，而是访问 CPU 缓存，CPU 缓存

是位于 CPU 与内存之间的临时存储器，它的容量比内存小得多但是交换速度却比内存快得多。

而缓存中的数据是内存中的一小部分数据，但这一小部分是短时间内 CPU 即将访问的，当

CPU 调用大量数据时，就可先从缓存中读取，从而加快读取速度。

按照读取顺序与 CPU 结合的紧密程度，CPU 缓存可分为：

*  一级缓存：简称 L1 Cache，位于 CPU 内核的旁边，是与 CPU 结合最为紧密的 CPU 缓存。
 *  二级缓存：简称 L2 Cache，分内部和外部两种芯片，内部芯片二级缓存运行速度与主频相同，外部芯片二级缓存运行速度则只有主频的一半。
 *  三级缓存：简称 L3 Cache，部分高端 CPU 才有。

**每一级缓存中所存储的数据全部都是下一级缓存中的一部分**，这三种缓存的技术难度和制造成本

是相对递减的，所以其容量也相对递增。当 **CPU **要读取一个数据时，**首先从一级缓存中查找**，

如果没有**再从二级缓存中查找**，如果还是没有**再从三级缓存中或内存中查找**。一般来说每级缓存

的命中率大概都有 80% 左右，也就是说全部数据量的 80% 都可以在一级缓存中找到，只剩下

20% 的总数据量才需要从二级缓存、三级缓存或内存中读取。

[CPU为什么要分三级缓存？][CPU]

## 2、cpu 缓存带来的问题 ##

CPU –> CPU 缓存 –> 主内存 数据读取之间的关系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70][]

当系统运行时，CPU执行计算的过程如下：

1.  程序以及数据被加载到主内存；
2.  指令和数据被加载到 CPU 缓存；
3.  CPU 执行指令，把结果写到高速缓存；
4.  高速缓存中的数据写回主内存；

如果服务器是单核 CPU，那么这些步骤不会有任何的问题，但是如果服务器是**多核 CPU**，

那么问题来了，以 Intel Core i7 处理器的高速缓存概念模型为例（图片来自《深入理解计算

机系统》）：

![format_png][]

假设如下场景：

1.  核 0 读取了一个字节，根据局部性原理，它相邻的字节同样被被读入核 0 的缓存；
2.  核 3 做了上面同样的工作，这样核 0 与核 3 的缓存拥有同样的数据；
3.  核 0 修改了那个字节，被修改后，那个字节被写回核 0 的缓存，但是该信息并没有写回主存；
4.  核 3 访问该字节，由于核 0 并未将数据写回主存，数据不同步；

为了解决数据不同步这一问题，CPU 制造商规定了一个**缓存一致性协议**。

## 3、缓存一致性协议 ##

每个 CPU 都有一级缓存，但是，我们却无法保证每个 CPU 的一级缓存数据都是一样的。

所以同一个程序，CPU 进行切换的时候，切换前和切换后的数据可能会有不一致的情况。

那么这个就是一个很大的问题了。如何保证各个 CPU 缓存中的数据是一致的。就是 CPU

的缓存一致性问题。

**总线锁**

一种处理一致性问题的办法是使用 **Bus Locking（总线锁）**。当一个 CPU 对其缓存中的数据

进行操作的时候，往总线中发送一个 Lock\# 信号。这个时候，所有 CPU 收到这个信号之后就

不操作自己缓存中的对应数据了，当操作结束，释放锁以后，所有的 CPU 就去内存中获取最新

数据更新。但是用锁的方式总是避不开性能问题。总线锁总是会导致 CPU 的性能下降。所以

出现另外一种维护 CPU 缓存一致性的方式，MESI。

**MESI**

MESI 是保持一致性的协议。它的方法是在 **CPU 缓存**中保存一个**标记位**，这个标记位有四种状态:

*  M（Modified）：修改缓存，当前 CPU 缓存的内容有效，但是数据已经被修改，与内存中的数据不一致，数据只在当前缓存里；
 *  E（Exclusive）：独占缓存，当前 CPU 缓存的内容有效，数据与内存中数据一致，数据只在当前 CPU 缓存里，而且其他处理器并没有可使用的缓存数据；
 *  S（Shared）：共享缓存，当前 CPU 缓存的内容有效，数据与内存数据一致，数据在多个缓存里面，多组缓存可以同时拥有针对同一内存地址的共享缓存段；
 *  I（Invalid）：失效缓存，当前 CPU 缓存行数据无效，这个说明 CPU 中的缓存已经不能使用了。

CPU的读取遵循下面几点：

*  如果缓存状态是 I，那么就从内存中读取，否则就从缓存中直接读取。
 *  如果缓存处于 M 或 E 的 CPU 读取到其他 CPU 有读操作，就把自己的缓存写入到内存中，并将自己的状态设置为 S。
 *  只有缓存状态是 M 或 E 的时候，CPU 才可以修改缓存中的数据，修改后，缓存状态变为 M。

这样，每个 CPU 都遵循上面的方式则 CPU 的效率就提高上来了。

## 4、可见性实现 ##

volatile 变量进行写操作时，JVM 会向处理器发送一条 Lock\# 前缀的指令，将这个变量所在缓存

行的数据写回到系统内存，同时其他 CPU 里缓存该内存地址的数据无效。线程在进行读操作时，

发现本地内存无效，然后从主内存获取最新的数据，从而保证多核 CPU 以及多线程的数据

可见性。

Lock\# 前缀多核处理器下的作用：

*  将当前处理器缓存行的数据写回到系统内存。
 *  这个写回内存的操作会使在其他 CPU 里缓存了该内存地址的数据无效。

## 5、指令重排序实现 ##

在执行程序时为了提高性能，编译器和处理器通常会对指令做重排序。即编译器或运行时都会

注意到这个变量是共享的，就不会把共享变量上的操作与其他内存操作进行重排序。指令重排序

对单线程没有什么影响，他不会影响程序的运行结果，但是会影响多线程的正确性。既然指令

重排序会影响到多线程执行的正确性，那么我们针对多线程共享的变量或代码就需要禁止重排序，

避免多线程执行导致不正确。JVM 是如何禁止重排序的？

在了解指令重排序前，需要了解 happen-before 重要原则：

*  程序次序规则：一个线程内，按照代码顺序，书写在前面的操作，happens-before 于书写在后面的操作。
 *  锁定规则：一个 unLock 操作，happens-before 于后面对同一个锁的 lock 操作。
 *  volatile 变量规则：对一个volatile变量的写操作，happens-before 于后面对这个变量的读操作。
 *  传递规则：如果操作 A happens-before 操作 B，而操作 B happens-before 操作C，则可以得出，操作 A happens-before 操作C
 *  线程启动规则：Thread 对象的 start 方法，happens-before 此线程的每个一个动作。
 *  线程中断规则：对线程 interrupt 方法的调用，happens-before 被中断线程的代码检测到中断事件的发生。
 *  线程终结规则：线程中所有的操作，都 happens-before 线程的终止检测，我们可以通过Thread.join() 方法结束、Thread.isAlive() 的返回值手段，检测到线程已经终止执行。
 *  对象终结规则：一个对象的初始化完成，happens-before 它的 finalize() 方法的开始。

Lock 前缀指令实际上相当于一个内存屏障(也成内存栅栏)，它确保指令重排序时不会把其后面的

指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面，即在执行到内存屏障

这句指令时，在它前面的操作已经全部完成，保证指令不会进行重排序。

# 三 volatile 实战 #

## 1、非 volatile 变量来控制线程停止 ##

创建一个类，通过非共享变量 sign 控制线程是否停止，sign false 表示不停止，如果为 true，

表示停止。

package com.jpeony.concurrent.volatiles;
    
    /**
     * sign标识是否停止线程：sign false表示不停止，如果为true 表示停止。
     *
     * @author yihonglei
     */
    public class StopThread {
        /**
         * 非volatile变量
         */
        private static boolean sign;
    
        /**
         * volatile变量
         */
        //volatile private static boolean sign;
        public static void main(String[] args) throws InterruptedException {
            Thread readThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (!sign) {
                        // System.out.println("加上println方法");
                    }
                }
            });
    
            // 启动线程
            readThread.start();
            // 休眠一秒
            Thread.sleep(1000);
            // 期望过一秒后线程停止
            sign = true;
        }
    }

从程序中，我们可以看出，一开始 sign 为默认值 false，当程序运行时，休眠一秒后，sign 会

变为 true，这个时候 while 循环应该就进不去，退出循环，线程自动退出。但是实际结果会是

这样吗?我们运行一下程序，看看是否停止了线程。

运行结果:

![20190212135740674.jpg][]

从运行结果可以看出，当把 sign 设置为 true 时，while 循环中并没有取到 true 值，而是一直

沿用初始值 false，所以循环没有停止，出现了死循环，线程无法退出。原因是 main 主线程

修改的是 main 线程中的变量 sign=true，而 readThread 线程中取到的是一开始的 false，

两个线程用的是自己私有栈的变量，互不干涉，解决这个问题的办法就是使用 volatile 关键字

定义变量，强制从公共堆栈中获取变量。

## 2、解决死循环 ##

将上述实例中的 sign 变量修改为 volatile private static boolean sign; // volatile变量

然后再运行程序，发现一秒后循环退出，线程终止。原因就是当使用 volatile 变量时，

线程每次获取共享的 sign 为最新变量。

## 3、在 while 中加上 System.out.println 方法线程为什么会自动退出 ##

不适用 volatile 变量，在while中加上println方法，线程自动退出。

package com.jpeony.concurrent.volatiles;
    
    /**
     * sign标识是否停止线程：sign false表示不停止，如果为true 表示停止。
     *
     * @author yihonglei
     */
    public class StopThread {
        /**
         * 非volatile变量
         */
        private static boolean sign;
    
        /**
         * volatile变量
         */
        //volatile private static boolean sign;
        public static void main(String[] args) throws InterruptedException {
            Thread readThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (!sign) {
                        System.out.println("加上println方法");
                    }
                }
            });
    
            // 启动线程
            readThread.start();
            // 休眠一秒
            Thread.sleep(1000);
            // 期望过一秒后线程停止
            sign = true;
        }
    }

该程序运行时会退出循环，不会出现线程无法退出。这看上去跟上面说到的共享变量测试实例

有矛盾，理论上 println 方法不应该影响变量 sign，但是怎么就导致了循环退出?

public void println(String x) {
       synchronized (this) {
           print(x);
           newLine();
       }
    
    }

从源码看出，println 使用了 synchronized 同步关键字，问题就出在这。因为 synchronized 处理

时影响了内存。

synchronized 处理时会经历以下几个步骤：

首先会获得同步锁，然后清空工作内存，从主内存拷贝对象副本到工作内存，执行代码，

刷新主内存数据（公共堆栈），释放同步锁。也就是说，在 while 中加上 println 方法后，

输出的时候从主内存拷贝 sign=true 数据到工作内存这个时候，while 循环拿到的不是 false，

而是 true，所以，while 循环退出，线程退出。

# 四 volatile 总结 #

## 1、volatile 特性 ##

*  volatile 关键字不支持原子性；
 *  volatile 是线程同步的轻量级实现，只能修饰变量；
 *  多线程访问 volatile 不会发生阻塞，因为只是公开读；
 *  volatile 主要解决变量在多个线程之间的可见性；

## 2、volatile 使用场景 ##

*  在访问变量时不需要加锁，可以使用；
 *  对于变量的写入操作不依赖变量的当前值，或者能确保只有单个线程更新变量的值；
 *  该变量不会与其他状态变量一起纳入不变性条件中；

# 参考文献 #

[https://crowhawk.github.io/2018/02/10/volatile/][https_crowhawk.github.io_2018_02_10_volatile]

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[CPU]: https://juejin.im/entry/6844903441974706190
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70]: /images/20220320/a7b0667c42804c6298b0c4f028ffb7d0.png
[format_png]: /images/20220320/6c318fa03bd34368acc32fd305a04d1c.png
[20190212135740674.jpg]: /images/20220320/b7b0328dddd2498aaac4110db5b06ea2.png
[https_crowhawk.github.io_2018_02_10_volatile]: https://crowhawk.github.io/2018/02/10/volatile/