Java volatile 关键字详细解析

曾经终败给现在 2023-10-18 23:41 130阅读 0赞

#### 文章目录 ####

*  1. Java 内存模型
 *  2. volatile 保证内存可见性
 *   *   *  2.1 Java 内存交互操作
         *  2.2 volatile如何保持内存可见性
 *  3. volatile 禁止指令重排序
 *   *   *  3.1 什么是指令重排序
         *  3.2 指令重排带来的问题
         *  3.3 volatile如何防止指令重排
 *  4. 另一个问题

## 1. Java 内存模型 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]

Java内存模型规定了所有的变量都存储在主内存，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中使用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存. 不同的线程之间也无法直接访问对方工作内存中的变量，**线程间变量的传递均需要自己的工作内存和主存之间进行数据同步**.

**该模型主要为解决处理器运算速度与存储设备速度差距过大的问题.**但是增加了工作内存作为缓存,在多线程场景下就会出现缓存一致性问题.

## 2. volatile 保证内存可见性 ##

内存可见性（Memory Visibility）:所有线程都能看到共享内存的最新状态.

#### 2.1 Java 内存交互操作 ####

Java 工作内存和主内存的交互操作主要由以下8种操作完成:

> 1.  `lock`：作用于主内存，把变量标识为线程独占状态
> 2.  `unlock`：作用于主内存，解除独占状态
> 3.  `read`：作用主内存，把一个变量的值从主内存传输到线程的工作内存
> 4.  `load`：作用于工作内存，把read操作传过来的变量值放入工作内存的变量副本中
> 5.  `use`：作用工作内存，把工作内存当中的一个变量值传给执行引擎
> 6.  `assign`：作用工作内存，把一个从执行引擎接收到的值赋值给工作内存的变量
> 7.  `store`：作用于工作内存的变量，把工作内存的一个变量的值传送到主内存中
> 8.  `write`：作用于主内存的变量，把store操作传来的变量的值放入主内存的变量中

#### 2.2 volatile如何保持内存可见性 ####

对于volatile关键字,它特殊的规则如下:

*  read、load、use动作必须连续出现.
 *  assign、store、write动作必须连续出现.

所以使用volatile变量能够保证以下特性:

1.  每次读取前必须先从主内存刷新最新的值.
2.  每次写入后必须立即同步回主内存当中, 其他线程在使用volatile变量时就会拿到最新值.

也就是说volatile关键字修饰的变量看到的随时是主内存中的最新值. 线程1中对变量v的最新修改，对线程2是可见的.值得注意的是, **volatile 不保证原子性**, 它只是使变量的读、写具有了“原子性”,因为变量的读写在底层实际是多个操作组合在一起的.

## 3. volatile 禁止指令重排序 ##

#### 3.1 什么是指令重排序 ####

JVM 为了尽可能减少内存操作速度远慢于CPU运行速度所带来的CPU空置影响, 会按照自己的一些规则将程序编写顺序打乱, 以尽可能充分地利用CPU–即写在后面的代码在时间顺序上可能会先执行,而写在前面的代码会后执行.

> 指令重排会发生在两个阶段：
> 
> 1.  编译期(jvm 加载字节码时)
> 2.  cpu 执行期

#### 3.2 指令重排带来的问题 ####

以一个实现单例模式的代码为例, 使用`synchronized`关键字将 `getInstance()`方法修饰同步方法, 对变量进行双重检查, 在多线程环境下使得大部分请求都不会进入阻塞代码块：

class Singleton {
        
        private static Singleton instance;
        private Singleton(){
        }
        public static Singleton getInstance() {
        
            if ( instance == null ) {
         //当instance不为null时，仍可能指向一个“被部分初始化的对象”
                synchronized (Singleton.class) {
        
                    if ( instance == null ) {
        
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

但实际上存在一个问题——当instance不为null时, 并不意味着 instance 对象一定完成了初始化, 其实instance可能作为一个被部分初始化的对象返回,这就会导致线程安全问题.

问题在于这行赋值语句:

instance = new Singleton();

它并不是一个原子操作, 其实它可以”抽象“为下面几条JVM指令:

memory = allocate();    //1：分配对象的内存空间
    initInstance(memory);   //2：初始化对象
    instance = memory;      //3：设置instance指向刚分配的内存地址

易知操作2依赖于操作1，但是操作3并不依赖于操作2, 所以JVM可以以“优化”为目的对它们进行重排序,经过重排序后执行顺序如下:

memory = allocate();    //1：分配对象的内存空间
    instance = memory;      //3：设置instance指向刚分配的内存地址（此时对象还未初始化）
    ctorInstance(memory);   //2：初始化对象

可以看到指令重排之后，`操作3` 排在了`操作2` 之前，即引用instance指向内存memory时，这段内存还没有完成初始化，即引用instance指向了一个"被部分初始化的对象"。此时，如果另一个线程调用getInstance方法，由于instance已经指向了一块内存空间，从而if条件判为false，方法返回instance引用，用户得到了没有完成初始化的“半个”单例.

解决这个问题，只需要将instance声明为`volatile`变量：

private static volatile Singleton instance;

#### 3.3 volatile如何防止指令重排 ####

volatile关键字通过 内存屏障 来防止指令被重排序,也就是重排序时不能把后面的指令重排序到内存屏障之前的位置.

只有一个CPU访问内存时并不需要内存屏障,但如果有多个CPU访问同一块内存,就需要内存屏障来保证一致性.

下面是基于保守策略的JMM内存屏障插入策略：

*  `在每个volatile读操作的前面插入一个LoadLoad屏障`  
    对于这样的语句Load1; LoadLoad; Load2，在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕
 *  `在每个volatile读操作的后面插入一个LoadStore屏障`  
    对于这样的语句Load1; LoadStore; Store2，在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕
 *  `在每个volatile写操作的前面插入一个StoreStore屏障`  
    对于这样的语句Store1; StoreStore; Store2，在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见
 *  `在每个volatile写操作的后面插入一个StoreLoad屏障`  
    对于这样的语句Store1; StoreLoad; Load2，在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见.它的开销是四种屏障中最大的,在大多数处理器的实现中.这个屏障是个万能屏障，兼具其它三种内存屏障的功能.

## 4. 另一个问题 ##

如果存在这种重排序问题，那么synchronized代码块内部是不是也可能出现相同的问题?

class Singleton {
        
        ...
            if ( instance == null ) {
        
                synchronized (Singleton.class) {
        
                    if ( instance == null ) {
        
                        instance = new Singleton(); // 操作A
                        System.out.println(instance.toString()); // 操作B,程序顺序规则
                    }
                }
            }
        ...
    }

调用instance.toString()方法时，instance也可能未完成初始化？  
我们需要明白 先行发生原则 中的 **程序次序规则**: [Java synchronized 关键字全解][Java synchronized]

程序次序规则：如果程序中操作A在操作B之前，那么线程中操作A将在操作B之前执行.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20190819142848376.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw==,size_16,color_FFFFFF,t_70#pic_center
[Java synchronized]: https://blog.csdn.net/weixin_45505313/article/details/99714007#1_synchronized__1