volatile 的用法及原理

RdouTyping 发布于2019-08-15 17:46 / 1250人阅读

摘要：下面具体分析的用法及原理，涉及到内存模型可见性重排序以及伪共享等方面。缓存的使用提高了的运行效率，但是对于多核处理器会有一些问题。需要注意的是，用于保证一个变量的可见性，但是对于这种复合操作是无法保证原子性的。

简介

在 Java 并发编程中，volatile 是经常用到的一个关键字，它可以用于保证不同的线程共享一个变量时每次都能获取最新的值。volatile 具有锁的部分功能并且性能比锁更好，所以也被称为轻量级锁。下面具体分析 volatile 的用法及原理，涉及到内存模型、可见性、重排序以及伪共享等方面。

内存模型

在深入理解 volatile 之前，先了解一些计算机的内存模型。当 CPU 执行运算的时候，需要从内存中取数据，由于 CPU 的运算速度远远快于内存的读取速度，所以 CPU 需要等数据，这个过程就浪费了 CPU 的时间。为了提高效率，在 CPU 和内存之间会有缓存（一般有三级缓存），缓存的读写速度高于内存，容量也会比内存小得多。当 CPU 读数据的时候会先从缓存中读，如果缓存未命中则会去内存读，并把数据放到缓存中，写数据的时候也会先写缓存，在适当的时候再将缓存中的数据刷新到内存中。

缓存的使用提高了 CPU 的运行效率，但是对于多核处理器会有一些问题。如果某个内存地址的数据同时被两个 CPU 缓存，其中一个 CPU 修改了这个地址的值，无论这个值是写入到了缓存中还是被刷新到了内存中，只要另一个 CPU 依然使用其缓存中的值，那还是旧值。因此对于多线程来说，需要一些手段来保证数据的一致性。

对于 Java 来说，程序运行在 JVM 上，JVM 提供了类似的内存抽象模型，如下图所示。

每个线程有自己的工作内存，相当于缓存，所有的线程共享主内存，相当于系统中的内存。线程之间往往会有共享变量，为了保证共享变量的可见性，需要采用 java 提供的并发技术。对于单个变量的可见性来说，volatile 是一种有效的机制。

内存可见性

先看下面的一段代码：

    int a = 1;
    boolean flag = false;
    int b = 3;
    
    // 线程1    
    a = 2;
    flag = true;
    
    // 线程2     
    if (flag) {
       b = a;
    }

上面的代码如果线程 1 执行后，线程 2 中的 flag 能立刻看到 flag 的新值吗？根据上面介绍的 Java 内存模型可以知道，答案是不一定。那么如何保证当线程 1 更新 flag 之后，线程 2 能够读取到最新的值呢？其实很简单，只需要给 flag 添加 volatile 修饰符。

那么 volatile 是如何做到的呢？我们想一想，根据 Java 内存模型，要实现这种功能该怎么做？应该是两步：1. 当线程 1 写 volatile 变量的时候，将这个值从缓存刷新到主内存中 2. 当线程 2 读取 volatile 变量的时候，将本地的工作内存置为无效，从主内存读取新值。

其实 volatile 的实现正是以上的原理，对于一个 volatile 变量的写操作会有一行以 lock 作为前缀的汇编代码。这个指令在多核处理器下会引发两件事：

将当前处理器缓存行的数据写回到主内存

这个写回内存的操作会使在其它 CPU 里缓存了该内存地址的数据无效

lock 前缀的指令会锁住系统总线或者是缓存，目的是保证在同一时间只有一个 CPU 会修改数据，使得修改具有原子性。根据 缓存一致性 协议， CPU 通过嗅探技术保证它的内部缓存、内存和其它处理器的缓存的数据的一致性。例如，一个处理器检测其它处理器打算写内存地址，而这个地址当前处于共享状态，那么正在嗅探的处理器将使它的缓存行无效，在下次访问相同的内存地址时，强制执行缓存行填充。

禁止重排序

volatile 除了保证内存可见性，还可以禁止重排序。在了解重排序之前，先看一段代码：

class Singleton {
    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

上面的代码一看就是单例模式，并且使用了双重加锁提高效率。稍微有经验的程序员还会发现，上面的写法是不正确的，应该给 instance 添加 volatile 修饰。那么为什么需要 volatile 呢？

其实问题出在 instance = new Singleton(); 这一行，这里是创建 Singleton 对象的地方，其实这里可以看成三个步骤：

memory = allocate(); //1: 分配对象的内存空间

ctorInstance(memory); //2: 初始化对象

instance = memory； //3: 设置 instance 指向刚分配的内存地址

上面的伪代码可能会被重排序。什么是重排序？编译器以及处理器有时候会为了执行的效率改变代码的执行顺序，这个被称为重排序。上面的三个步骤可能会被重排序为下面的步骤：

memory = allocate(); //1: 分配对象的内存空间

instance = memory； //2: 设置 instance 指向刚分配的内存地址
// 注意：此时对象还没有被初始化

ctorInstance(memory); //3: 初始化对象

在这种情况下，当一个线程执行到 instance = memory; 的时候，对象还没有被初始化，另一个线程也调用了 getInstance 方法，发现 instance 引用不为 null，就会认为这个对象已经创建好了，从而使用了未初始化的对象。

为什么 volatile 可以避免上面的问题？其实是因为 volatile 会禁止重排序，方法是插入了内存屏障，具体原理较复杂，这里就不深入分析了。

伪共享

CPU 缓存是以缓存行为单位进行存取的，一般一个缓存行是 64 字节，如果两个 volatile 变量被缓存在同一个缓存行，并且有多个 CPU 缓存了同一行数据，那么会出现 伪共享 的问题，造成性能问题。

例如，CPU A 以及 CPU B 都在同一个缓存行缓存了共享变量 X 和 Y，如果 CPU A 修改了 X，那么 CPU B 中的缓存行也就失效了，如果 CPU 只是需要读取 Y ，却因为 X 使得整个缓存行都要重新读取，这就不划算了，这叫做伪共享。

解决伪共享主要是让不同的 volatile 变量不要缓存到同一个缓存行，可以利用填充技术来解决，具体可以参考这篇文章：Java中的伪共享以及应对方案

总结

volatile 作为一个轻量级的锁可以实现内存可见性以及禁止重排序，常用于修饰标记变量以及双重加锁的场景等。需要注意的是，volatile 用于保证一个变量的可见性，但是对于 i++ 这种复合操作是无法保证原子性的。另外，注意伪共享问题可以进一步提升性能。

参考

《Java 并发编程的艺术》

如果我的文章对您有帮助，不妨点个赞支持一下(^_^)

GPU云服务器云服务器 volatile的实现原理及用法 ddos攻击原理及防范人工智能原理及应用

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/69440.html

Javag工程师成神之路（2019正式版）

摘要：结构型模式适配器模式桥接模式装饰模式组合模式外观模式享元模式代理模式。行为型模式模版方法模式命令模式迭代器模式观察者模式中介者模式备忘录模式解释器模式模式状态模式策略模式职责链模式责任链模式访问者模式。主要版本更新时间备注 v1.0 2015-08-01 首次发布 v1.1 2018-03-12 增加新技术知识、完善知识体系 v2.0 2019-02-19 结构...

Olivia 2019-08-16 15:14 评论0 收藏0
金三银四，2019大厂Android高级工程师面试题整理

摘要：原文地址游客前言金三银四，很多同学心里大概都准备着年后找工作或者跳槽。最近有很多同学都在交流群里求大厂面试题。最近整理了一波面试题，包括安卓JAVA方面的，目前大厂还是以安卓源码，算法，以及数据结构为主，有一些中小型公司也会问到混合开发的知识，至于我为什么倾向于混合开发，我的一句话就是走上编程之路，将来你要学不仅仅是这些，丰富自己方能与世接轨，做好全栈的装备。原文地址：游客kutd...

tracymac7 2019-08-16 16:18 评论0 收藏0
一个具体的例子学习Java volatile关键字

摘要：下面我们就用一个具体的例子来学习的用法。主内存中的变量如果被线程使用到，则线程的工作内存会维护一份主内存变量的副本拷贝。在变量前加上关键字进行修饰，这样在计数器线程里每次读取的值时，会强制该线程从主内存读取，而不是从当前线程的工作内存读取。相信大多数Java程序员都学习过volatile这个关键字的用法。百度百科上对volatile的定义： volatile是一个类型修饰符（type...

周国辉 2019-08-16 13:28 评论0 收藏0
JAVA并发编程之-Volatile关键字及内存可见性

摘要：的缺点频繁刷新主内存中变量，可能会造成性能瓶颈不具备操作的原子性，不适合在对该变量的写操作依赖于变量本身自己。作者：毕来生微信：878799579 1. 什么是JUC? JUC全称 java.util.concurrent 是在并发编程中很常用的实用工具类 2.Volatile关键字 1、如果一个变量被volatile关键字修饰，那么这个变量对所有线程都是可见的。2、如果某条线程修...

xcold 2019-08-19 10:12 评论0 收藏0