volatile超详细讲解

本是古典何须时尚 2022-10-15 12:50 252阅读 0赞

**目录**

写在前面

一、什么是volatile

二、JVM（java虚拟机）、JMM（java内存模型）

三、volatile内存可见性验证

四、可见性说明

五、volitale不保证原子性验证

六、volatile不保证原子性理论解释

七：volatile不保证原子性问题解决

八、volatile指令重排

九、单例模式在多线程环境下可能存在安全问题

--------------------

# 写在前面 #

很多小伙伴相信都会听说过volatile关键字，但是这个关键字有什么作用呢？也许大体也能明白，但是如果碰上较真的面试官，可能会直接蒙了。

今天就给大家充分分析一下volatile关键字到底有什么作用~

# 一、什么是volatile #

volatile是java的一个关键字，volatile是Java虚拟机提供的轻量级的同步机制。

volatile有三个特性：1.保证可见性。2.不保证原子性。3.禁止指令重排序。

# 二、JVM（java虚拟机）、JMM（java内存模型） #

JMM(Java内存模型 Java Memory Model,简称JMM)本身是一种抽象的概念并不真实存在,它描述的是一组规则或规范,通过这组规范定义了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式。

JMM关于同步的规定:

1线程解锁前,必须把共享变量的值刷新回主内存

2线程加锁前,必须读取主内存的最新值到自己的工作内存

3加锁解锁是同一把锁

由于JMM运行程序的实体是线程,而每个线程创建时JM都会为其创建一个工作内存(有些地方称为栈空间),工作内存是每个线程的私有数据区域,而Java内存模型中规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可以访问,但线程对变量的操作(读取赋值等)必须在工作内存中进行,首先要将变量从主内存拷贝的自己的工作内存空间,然后对变量进行操作,操作完成后再将变量写回主内存,不能直接操作主内存中的变量,各个线程中的工作内存中存储着主内存中的变量副本拷贝,因此不同的线程间无法访问对方的工作内存,线程间的通信(传值)必须通过主内存来完成,其简要访问过程如下图:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 1][]

# 三、volatile内存可见性验证 #

/**
    * volatile验证内存的可见性
    */
    public class VolatileTest {
    
        public static void main(String[] args) {
    
            Dt1 dt1 = new Dt1();
            //新线程，三秒中后将num值设置为100
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " start");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                dt1.setDt();
                System.out.println(Thread.currentThread().getName() + " date 0 -> " + dt1.num);
            }, "Thread1").start();
    
            while(dt1.num == 0){
                //num不变的话会一直卡在这
                //num不用volatile修饰的话，会一直卡在这，main的最后一段不会打印
            }
            System.out.println("main 结束，num值改变了！");
        }
    }
    
    /**
    * 1.不加volatile，num没有可见性。
    * 2.添加volatile可以解决可见性问题
    */
    class Dt1{
        //volatile int num = 0;
        int num = 0;
        public void setDt(){
            this.num = 100;
        }
    }

# 四、可见性说明 #

各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回到主内存中的。

这就可能存在一个线程AAA修改了共享变量X的值但还未写回主内存时，另一个线程BBB又对主内存中同一个共享变量X进行操作，但此时AAA线程工作内存中共享变量X对线程BBB来说并不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题。

# **五、volitale不保证原子性验证** #

/**
    * 验证volatile不保证数据的原子性
    * 什么是原子性？在做某个业务时，中间的逻辑不可以被分割。
    */
    public class VolatileTest2 {
    
        public static void main(String[] args) {
    
            Dt2 dt2 = new Dt2();
    
            //20个线程，每个线程将num加1000次
            for (int i = 0;i < 20; i++){
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        dt2.addDt();
                    }
                }).start();
            }
    
            while (Thread.activeCount() > 2){
                Thread.yield();
            }
            System.out.println(dt2.num);
            //发现，最后的打印结果并不是20000！所以volatile并不会保证++操作的原子性
        }
    }
    
    /**
    * 用volatile修饰，++操作并不会保证原子性
    */
    class Dt2{
        volatile int num = 0;
        //int num = 0;
        public void addDt(){
            this.num ++;
        }
    }

# 六、volatile不保证原子性理论解释 #

num++会被分解成3个机器指令，三个指令并不是一个原子操作，所以volitale并不会保证操作的原子性：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 2][]

# 七：volatile不保证原子性问题解决 #

1.使用synchronized（大材小用）

class Dt2{
        int num = 0;
        public synchronized void addDt(){
            this.num ++;
        }
    }

2.atomic原子类

import java.util.concurrent.atomic.AtomicInteger;
    
    /**
    * 使用AtomicInteger原子类
    */
    public class VolatileTestAtomicInteger {
    
        public static void main(String[] args) {
    
            Dt3 dt3 = new Dt3();
    
            //20个线程，每个线程将num加1000次
            for (int i = 0;i < 20; i++){
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        dt3.addDt();
                    }
                }).start();
            }
    
            while (Thread.activeCount() > 2){
                Thread.yield();
            }
            System.out.println(dt3.num);
            //发现，最后的打印结果就是20000！
        }
    }
    
    class Dt3{
        AtomicInteger num = new AtomicInteger();//默认是0
        public void addDt(){
            num.getAndIncrement();
        }
    }

# 八、volatile指令重排 #

1.什么是有序性：

计算机在执行程序时，为了提高性能，编译器和处理器常常会对 指令做重排，一般分为以下3种：

源代码->编译器优化的重排->指令并行的重排->内存系统的重排->最终执行的指令。

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重排序时必须要考虑指令之间的 数据依赖性（先有你爹才能有你……）。

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

（举例：高考做卷子，优先做会的，并不是根据题目来顺序做……）

2.指令重排案例：

int x = 11; // 语句1
    int y = 12; // 语句2
    x = x + 5; // 语句3
    y = x * x; // 语句4
    
    // 指令重排之后，可能会出现以下几种情况（对结果并不会有影响）
    1234
    2134
    1324
    
    //不可能出现4123。因为数据依赖性，语句4依赖于x声明的值、x计算后的值、y的声明。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 3][]

/**
    * method2和method2多线程情况下，有可能会出现a=6，也有可能出现a=5，因为语句1和语句2指令重排
    */
    public class ReSortSeqDemo{
        int a = 0;
        boolean flag = false;
        public void method1(){
            a = 1; // 语句1
            flag = true; // 语句2
        }
        // 多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
        public void method2(){
            if(flag){
                a = a + 5; // 语句3
                System.out.println("value a = " + a);
            }
        }
    }

3.指令重排小总结

volatile实现 禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。

先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

一是保证特定操作的执行顺序，

二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。

由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说 通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 4][]

4.线程安全性获得保证

工作内存与主内存同步延迟现象导致的可见性问题：

可以使用synchronized或volatile关键字解决，它们都可以使一个线程 修改后的变量立即对其他线程可见。

对于指令重排导致的可见性问题和有序性问题：

可以利用volatile关键字解决，因为volatile的另外一个作用就是禁止重排序优化。

# **九、单例模式在多线程环境下可能存在安全问题** #

1.代码示例

public class SingletonDemo {
    
        //双端检锁需要使用volatile
        private volatile static SingletonDemo instance = null;
    
        private SingletonDemo(){
            System.out.println("我是私有构造方法");
        }
    
        //这里加synchronized也可以实现单例，但是太重
        public static SingletonDemo getInstance(){
            if(instance == null){
                instance = new SingletonDemo();
            }
            return instance;
        }
    
        //DCL（Double check Lock 双端检锁机制）
        public static SingletonDemo getInstance2(){
            if(instance == null){
                synchronized (SingletonDemo.class){
                    if(instance == null){
                        instance = new SingletonDemo();
                    }
                }
            }
            return instance;
        }
        public static void main(String[] args) {
            //单线程下的单例模式，私有构造方法只执行一次
    //        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    //        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    //        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    
    
            //并发模式下
    //        for (int i = 0; i < 10; i++) {
    //            new Thread(() -> {
    //                //并发下，单例模式的构造方法会被调用很多次，有线程不安全问题
    //                SingletonDemo.getInstance();
    //            }, String.valueOf(i)).start();
    //        }
    
            //双端检锁
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    //并发下，单例模式的构造方法会被调用很多次，有线程不安全问题
                    SingletonDemo.getInstance2();
                }, String.valueOf(i)).start();
            }
        }
    }

2.为什么DCL（双端检锁机制）一定要用volatile？

DCL（双端检锁）机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排。

原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象 可能没有完成初始化。

instance = new SingletonDemo();// 可以分为以下3步完成（伪代码）
    memory = allocate(); // 1.分配对象内存空间
    instance(memory); // 2.初始化对象
    instance = memory; // 3.设置instance指向刚分配的地址，此时instance!=null。

步骤2和步骤3 不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。

假如重排后：

instance = new SingletonDemo();// 可以分为以下3步完成（伪代码）
    memory = allocate(); // 1.分配对象内存空间
    instance = memory; // 3.设置instance指向刚分配的地址，此时还没有完成初始化！此时如果有另一个线程也同时执行到这，导致这俩线程初始化的对象并不是同一个对象。
    instance(memory); // 2.初始化对象

但是指令重排只会保证串行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。

所以当一条线程访问instance不为null时，由于指令重排序，instance实例未必已初始化完成，也就造成了线程安全问题，导致两次取得的单例对象并不是同一个对象。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70]: /images/20221014/b16f807dbc234126857c9468203402bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 1]: /images/20221014/ddbda644f8194ee68306dd5db07d2401.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 2]: /images/20221014/53a6bceb35704bcb95238d4c676114bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210525160534360.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2021052516055984.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfYXJ0X3hpYW5n,size_16,color_FFFFFF,t_70