#yyds干货盘点# 关键字: volatile详解

Posted 2022-03-29 灰太狼_cxh

关键字: volatile详解

volatile的作用详解

防重排序

我们从一个最经典的例子来分析重排序问题。大家应该都很熟悉单例模式的实现，而在并发环境下的单例实现方式，我们通常可以采用双重检查加锁(DCL)的方式来实现。其源码如下：

public class Singleton 
    public static volatile Singleton singleton;
    /**
     * 构造函数私有，禁止外部实例化
     */
    private Singleton() ;
    public static Singleton getInstance() 
        if (singleton == null) 
            synchronized (singleton.class) 
                if (singleton == null) 
                    singleton = new Singleton();
                
            
        
        return singleton;
    

现在我们分析一下为什么要在变量singleton之间加上volatile关键字。要理解这个问题，先要了解对象的构造过程，实例化一个对象其实可以分为三个步骤：

分配内存空间。

初始化对象。

将内存空间的地址赋值给对应的引用。

但是由于操作系统可以对指令进行重排序，所以上面的过程也可能会变成如下过程：

分配内存空间。

将内存空间的地址赋值给对应的引用。

初始化对象

如果是这个流程，多线程环境下就可能将一个未初始化的对象引用暴露出来，从而导致不可预料的结果。因此，为了防止这个过程的重排序，我们需要将变量设置为volatile类型的变量。

实现可见性

可见性问题主要指一个线程修改了共享变量值，而另一个线程却看不到。引起可见性问题的主要原因是每个线程拥有自己的一个高速缓存区——线程工作内存。volatile关键字能有效的解决这个问题，我们看下下面的例子，就可以知道其作用：

public class VolatileTest 
    int a = 1;
    int b = 2;

    public void change()
        a = 3;
        b = a;
    

    public void print()
        System.out.println("b="+b+";a="+a);
    

    public static void main(String[] args) 
        while (true)
            final VolatileTest test = new VolatileTest();
            new Thread(new Runnable() 
                @Override
                public void run() 
                    try 
                        Thread.sleep(10);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    test.change();
                
            ).start();
            new Thread(new Runnable() 
                @Override
                public void run() 
                    try 
                        Thread.sleep(10);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    test.print();
                
            ).start();
        
    

保证原子性:单次读/写

volatile不能保证完全的原子性，只能保证单次的读/写操作具有原子性。先从如下两个问题来理解（后文再从内存屏障的角度理解）：​​​​

​ 问题1： i++为什么不能保证原子性?

对于原子性，需要强调一点，也是大家容易误解的一点：对volatile变量的单次读/写操作可以保证原子性的，如long和double类型变量，但是并不能保证i++这种操作的原子性，因为本质上i++是读、写两次操作。

现在我们就通过下列程序来演示一下这个问题：

public class VolatileTest01 
    volatile int i;

    public void addI()
        i++;
    

    public static void main(String[] args) throws InterruptedException 
        final  VolatileTest01 test01 = new VolatileTest01();
        for (int n = 0; n < 1000; n++) 
            new Thread(new Runnable() 
                @Override
                public void run() 
                    try 
                        Thread.sleep(10);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    test01.addI();
                
            ).start();
        
        Thread.sleep(10000);//等待10秒，保证上面程序执行完成
        System.out.println(test01.i);
    

大家可能会误认为对变量i加上关键字volatile后，这段程序就是线程安全的。大家可以尝试运行上面的程序。下面是我本地运行的结果：981可能每个人运行的结果不相同。不过应该能看出，volatile是无法保证原子性的(否则结果应该是1000)。原因也很简单，i++其实是一个复合操作，包括三步骤：

读取i的值。

对i加1。

将i的值写回内存。 volatile是无法保证这三个操作是具有原子性的，我们可以通过AtomicInteger或者Synchronized来保证+1操作的原子性。 注：上面几段代码中多处执行了Thread.sleep()方法，目的是为了增加并发问题的产生几率，无其他作用。

问题2： 共享的long和double变量的为什么要用volatile?

因为long和double两种数据类型的操作可分为高32位和低32位两部分，因此普通的long或double类型读/写可能不是原子的。因此，鼓励大家将共享的long和double变量设置为volatile类型，这样能保证任何情况下对long和double的单次读/写操作都具有原子性。

volatile 的实现原理

volatile 可见性实现

volatile 变量的内存可见性是基于内存屏障(Memory Barrier)实现:

内存屏障，又称内存栅栏，是一个 CPU 指令。

在程序运行时，为了提高执行性能，编译器和处理器会对指令进行重排序，JMM 为了保证在不同的编译器和 CPU 上有相同的结果，通过插入特定类型的内存屏障来禁止+ 特定类型的编译器重排序和处理器重排序，插入一条内存屏障会告诉编译器和 CPU：不管什么指令都不能和这条 Memory Barrier 指令重排序。

写一段简单的 Java 代码，声明一个 volatile 变量，并赋值。

public class Test 
    private volatile int a;
    public void update() 
        a = 1;
    
    public static void main(String[] args) 
        Test test = new Test();
        test.update();
    

volatile 有序性实现

volatile 的 happens-before 关系

happens-before 规则中有一条是 volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。

//假设线程A执行writer方法，线程B执行reader方法
class VolatileExample 
    int a = 0;
    volatile boolean flag = false;
    
    public void writer() 
        a = 1;              // 1 线程A修改共享变量
        flag = true;        // 2 线程A写volatile变量
     
    
    public void reader() 
        if (flag)          // 3 线程B读同一个volatile变量
        int i = a;          // 4 线程B读共享变量
        ……
        
    

volatile 禁止重排序

为了性能优化，JMM 在不改变正确语义的前提下，会允许编译器和处理器对指令序列进行重排序。JMM 提供了内存屏障阻止这种重排序。