我所理解的JMM--5 volatile内存语义

╰半夏微凉° 2022-11-25 13:13 123阅读 0赞

### 综述 ###

> 本文讲解`volatile`在`jsr 133`规范内存语义，本文需要前置知识  
> (1) new 是否为原子操作 [博主对new的理解文章][new]  
> (2) 内存屏障 [博主内存屏障知识点文章][Link 1]

我们先看看`volatile`具有哪些功能

(1) 保证`long`，`double`是单次读写的原子性  
(2) 变量的可见性  
(3) 基于`happer-before`规则下禁止重排序

### (1)保证`long`，`double`是单次读写的原子性 ###

***背景硬件知识:***  
数据总线：用于传输的管道.

我们常规的现代化`pc`数据总线往往都低于`64位`.(`64 位cpu`不是指数据总线和地址总线都是`64`的`cpu`，而是`寄存器`一次可以最大处理数据的位数。)

***带来的问题：***  
`long`和`double`都是`64 bit`，而数据总线却少于`64 bit`，此时我们会将`long`和`double`赋值和读取分成两次`32 bit`，在多线程环境下我们将有可能得到不完整的`long`或者`double`对象.

如下：

public class Main {
        
        static long commonFlag = 0;
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
    
                /**
                 * 此时  0xFFFFFFFFFFFFFFFFL 会拆分两个32位0xFFFFFFFF传输
                 * 
                 */
                           //32位
                           //0xFFFFFFFF
                commonFlag = 0xFFFFFFFFFFFFFFFFL;
            }).start();
    
            int i = 0;
            //粗略的让子线程子线程执行完成后在执行后续操作
            while (i++ < 100) {
        
            }
            /**
             *  commonFlag 可能会得到 0xFFFFFFFF_00000000L
             *                  或者 0x00000000_FFFFFFFFL  
             */
            System.out.println(commonFlag);
        }
    }

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

为了避免上述问题`volatile`提供了64位原子读写功能:

public class Main {
        
    	//用volatile修饰
        static volatile long commonFlag = 0;
      	
      	//...
    }

### ***(2) 变量的可见性*** ###

上述代码：

public class Main {
        
        static  int commonFlag = 0;
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                commonFlag = 1;
            }).start();
    
            int i = 0;
            //粗略的让子线程子线程执行完成后在执行后续操作
            while (i++ < 2) {
        
            }
            /**
             *  commonFlag 可能会得到 1
             *                  或者 0
             */
            System.out.println(commonFlag);
        }
    }

由于子线程执行`commonFlag = 1;`时并没有会写到主内存导致主线程读取时还是旧数值。我们只需要`commonFlag`用`volatile`修饰即可保证在更新某个变量时会立即刷回主内存而不是等候一段时间。  
我们看下这个问题示意图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]

### (3) 基于`happer-before`规则下禁止重排序 ###

我们在`happer-before`规则有如下一条：  
(3) 对一个`volatile`域的写，`happens- before`于任意后续对这个`volatile`域的读。

这个条规则被大量用于`JUC`,`CAS`库等。  
这条规则会限制编译器和cpu执行时部分乱序行为。  
可参考笔者上文[我所理解的JMM–4 happen-before  
][JMM_4 happen-before]。

我们看下这个规则的应用场景：  
`DCL(double check lock)单例`

我们首先看下`static Main instance;`不加`volatile`的`dcl`

public class Main {
        
        static Main instance;
        String name;
        public Main(String name) {
        
            this.name = name;
        }
    
        public static Main getInstance() {
        
            if (instance == null) {
        
                synchronized (Main.class) {
        
                    if (instance != null) {
        
                        instance = new Main("Jack Ma");
                    }
                }
            }
            return instance;
        }
    }

上述代码看着近乎完美，但是在多线程下将会出现如下空引用问题：

public static void main(String[] args) {
        
    
            Thread thread = new Thread(() -> {
        
                Main instance = getInstance();
            });
            thread.start();
    
            //粗略的保证子线程执行了 Main instance = getInstance();
            int i = 0;
            while (i++ < 20) {
        
            }
            //getInstance().name是null
            System.out.println(getInstance().name);
        }

上述代码有可能出现`getInstance().name`输出`name`为`null`，导致这一现象原因：代码乱序。

首先我们需要明确几点：  
(1)`instance = new Main("Jack Ma");`是一个非原子性操作([我所理解的JMM-- 2 new原子性][new])。  
(2) 编译器只要不破坏`happer-before`和单线程正确性情况(as-if-serial)可以随意重排序语句。

我们把一个`New`操作简单分为如下3步骤：  
`New-One`:为对象分配一个堆区  
`New-Two`:在堆区上调用初始化函数  
`New-Three`:把对象堆地址赋值给本地变量

我们把上述三步放入代码中：

public class Main {
        
        static Main instance;
        String name;
    
        //`New-Two` 初始化函数
        public Main(String name) {
        
            this.name = name;
        }
    
        public static Main getInstance() {
        
            if (instance == null) {
        
                synchronized (Main.class) {
        
                    if (instance == null) {
        
                        //`New-One` 申请堆内存此处可以用过字节码去看
                        //`New-Three` 将 new Main()赋值给instance
                        instance = new Main("Jack Ma");
                    }
                }
            }
            return instance;
        }
        public static void main(String[] args) {
        
    
            Thread thread = new Thread(() -> {
        
                Main instance = getInstance();
            });
            thread.start();
    
            //粗略的保证子线程执行了 Main instance = getInstance();
            int i = 0;
            while (i++ < 20) {
        
            }
    
            System.out.println(getInstance().name);
        }
    }

在单线程下`New-Two`和`New-Three`之间，允许先执行`New-Three`，并且不会有影响。那么我们在多线程情况下会发生什么？主线程在第一个判断`if (instance == null)`的时候直接返回了一个未初始化对象，导致`name`没有赋值。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]  
所以为了防止`New-Two`，`New-Three` 乱序，因此我们给`static Main instance;`加上`volatile`修饰。关于为什么加上volatile可以防止乱序可以参考[我所理解的JMM–4 happen-before][JMM_4 happen-before].  
简而言之就是为了`volatile`变量赋值之前会插入`StoreStore`内存屏障,保证之前的写入语句已经完成执行且写入主内存。

### volatile在x86汇编层面的实现 ###

`volatile` 依靠内存屏障实现。我们只需要插入对应屏障即可

如下：

public class Main {
        
        static int commonFlag = 0;
        static volatile int volatileVar = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                //第8行
                commonFlag = 2;
                //STORESTORE屏障 屏障在执行volatileVar = 2;时 commonFlag已经刷新回主内存
                //第10行  volatileVar 由于是volatile修饰的 所以会直接刷回主内存
                volatileVar = 2;
    
            }).start();
    
            int i = 0;
            //粗略的让子线程子线程执行完成后在执行后续操作
            while (i++ < 100) {
        
            }
    
            //第18行  volatileVar 由于是volatile修饰的所以直接从主内存中读取
            System.out.println(volatileVar);
            //LOADLOAD 保证commonFlag 读取到最新的数值
            //第20行
            System.out.println(commonFlag);
        }
    }

**我们顺带看下x86平台下屏障类型的具体实现:**  
`x86`由于拥有强悍的内存模型，因此只有`storeload`屏障类型，而其他类型屏障只是写给编译器看，让他们不要胡乱优化乱序。

我们看下汇编级别的代码：

// (java 9) hotspot/src/os_cpu/linux_x86/vm/orderAccess_linux_x86.inline.hpp
    //给编译器看 x86不要这个屏障，因为x86自身内存保证不会出现需要loadload的情况
    inline void OrderAccess::loadload()   {
         compiler_barrier(); }
    //同上
    inline void OrderAccess::storestore() {
         compiler_barrier(); }
    //同上
    inline void OrderAccess::loadstore()  {
         compiler_barrier(); }
    //万能屏障类型
    inline void OrderAccess::storeload()  {
         fence();            }
    inline void OrderAccess::acquire()    {
         compiler_barrier(); }
    inline void OrderAccess::release()    {
         compiler_barrier(); }
    inline void OrderAccess::fence() {
        
      //判断是否为多处理器 multiple processor
      if (os::is_MP()) {
        
        // always use locked addl since mfence is sometimes expensive
    #ifdef AMD64
    	//嵌入汇编代码
        __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");
    #else
        __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
    #endif
      }
      compiler_barrier();
    }

`__asm__ volatile`或者`__asm__ __volatile__`表示嵌入汇编代码，其中`__volatile__`和`volatile` 表示告诉编译器不要优化这行语句，不然有可能会被删除。

`lock`前缀作用有两个：  
(1) 全屏障作用  
(2) 本条语句关联内存会强制同步到主内存，保证一致性

如果多核处理器每个`cpu`都有本条语句操作数的缓存，那么只需要把数据会写到缓存即可，由于每个cpu都有这个操作数的缓存，所以不需要控制总线锁，只需要更新其他`cpu`缓存即可。如果部分`cpu`并没有缓存这个缓存 `lock`可能会锁数据总线，从而保证一致性。

[从HotSpot源码看Java volatile][HotSpot_Java volatile]

[What does **asm** **volatile** do in C?][What does _asm_ _volatile_ do in C]

[new]: https://blog.csdn.net/qfanmingyiq/article/details/107445789
[Link 1]: https://blog.csdn.net/qfanmingyiq/article/details/107449052
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221124/bfa4f322dde14e1191b73aeded2bf9f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]: /images/20221124/4454bf83868240edb41a91cd561d35fc.png
[JMM_4 happen-before]: https://blog.csdn.net/qfanmingyiq/article/details/107743473
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]: /images/20221124/7e39eed1a45f4f318d926cf84dd8d510.png
[HotSpot_Java volatile]: http://kexianda.info/2017/04/28/%E4%BB%8EHotSpot%E6%BA%90%E7%A0%81%E7%9C%8BJava-volatile/
[What does _asm_ _volatile_ do in C]: https://stackoverflow.com/questions/26456510/what-does-asm-volatile-do-in-c