并发编程 — 深入解析 volatile 关键字

最新推荐文章于 2024-07-05 17:54:33 发布

瞎胡扯

最新推荐文章于 2024-07-05 17:54:33 发布

阅读量153

点赞数

分类专栏：并发编程文章标签：编译器 java volatile

本文链接：https://blog.csdn.net/small_love/article/details/111033866

版权

并发编程专栏收录该内容

36 篇文章 9 订阅

订阅专栏

在上篇文章《缓存一致性问题》，今天就聊聊 volatile 关键字。

volatile 关键字规则

Java内存模型对volatile关键字定义了一些特殊的访问规则，当一个变量被volatile修饰后，它将具备两种特性，或者说volatile具有下列两层语义：

第一、保证了不同线程对这个变量进行读取时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。 (volatile 解决了线程间共享变量的可见性问题)。
第二、禁止进行指令重排序，阻止编译器对代码的优化。

保证可见性

针对第一点，volatile保证了不同线程对这个变量进行读取时的可见性，具体表现为：

第一：使用 volatile 关键字会强制将在某个线程中修改的共享变量的值立即写入主内存。
第二：使用 volatile 关键字的话，当线程 2 进行修改时，会导致线程 1 的工作内存中变量的缓存行无效（反映到硬件层的话，就是 CPU 的 L1或者 L2 缓存中对应的缓存行无效);
第三：由于线程 1 的工作内存中变量的缓存行无效，所以线程 1再次读取变量的值时会去主存读取。

通过这一点我们可以知道 volatile 保证了可见性。什么是可见性可以查看《可见性、原子性、有序性 BUG源头》。

禁止重排序

JMM针对编译器指定的volatile重排序规则。

	第二个操作
第一个操作	普通读/写	volatile读	volatile写
普通读/写			NO
volatile读	NO	NO	NO
volatile写		NO	NO

从表中可以看出：

当第二个操作时volatile写时，不管第一个操作是什么，都不能重排序。这个确保volatile写之前的操作不会被编译器重排序到volatile写之后。
当第一个操作时volatile读时，不管第二个操作是什么，都不能重排序。这个确保volatile读之后的操作不会被编译器重排序到volatile读之前。
当第一个操作时volatile写时，第二个操作是volatile读时，不能重排序。

由此可知，volatile禁止了编译器在编译时对指令的重排序，之前说过，指令重排序除了编译器，处理器也会对指令进行重排序，那么volatile又是怎么做到的呢？这个是通过在编译器生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器进行重排序的。

深入解析 volatile

上面我们说了在 Java 内存模型方面对 volatile 定义了一些规范，我们知道处理 JMM内存模型中存在缓存之外，在处理器层面也存在高速缓存和指令重排序的情况，那么Java又是怎么做到的呢？

我满看下下面一段代码，分别反编译加了不加 volatile 关键字和添加了 volatile 关键字的汇编指令。

public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if(instance ==null) {
            synchronized(Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    public static void main(String[] args) {
       
    }
}

1、未加volatile 关键字

 // 未使用volatile修饰
  0x000000010d29e931: movabs $0x7955f12a8,%rsi  ;   {oop(a 'java/lang/Class' = 'main/Singleton')}
  0x000000010d29e93b: mov    %rax,%r10
  0x000000010d29e93e: shr    $0x3,%r10
  0x000000010d29e942: mov    %r10d,0x68(%rsi)
  0x000000010d29e946: shr    $0x9,%rsi
  0x000000010d29e94a: movabs $0xfe403000,%rax
  0x000000010d29e954: movb   $0x0,(%rsi,%rax,1)  ;*putstatic instance
                                                ; - main.Singleton::getInstance@24 (line 10)

1、加了volatile 关键字

// 使用volatile修饰
 0x000000011435394f: movabs $0x7955f12a8,%rsi  ;   {oop(a 'java/lang/Class' = 'main/Singleton')}
  0x0000000114353959: mov    %rax,%r10
  0x000000011435395c: shr    $0x3,%r10
  0x0000000114353960: mov    %r10d,0x68(%rsi)
  0x0000000114353964: shr    $0x9,%rsi
  0x0000000114353968: movabs $0x10db6e000,%rax
  0x0000000114353972: movb   $0x0,(%rsi,%rax,1)
  0x0000000114353976: lock addl $0x0,(%rsp)     ;*putstatic instance
                                                ; - main.Singleton::getInstance@24 (line 10)

很明显，在movb $0x0,(%rsi,%rax,1) 之后，加了volatile修饰的汇编代码后面多了一条汇编指令lock addl $0x0,(%rsp)，这个操作相当于一个内存屏障，指令重排时不能把后面的指令重排序到内存屏障之前的位置，当只有一个CPU访问内存时，并不需要内存屏障，当如果有两个或多个CPU访问同一块内存，且其中有一个在观测另一个，就需要内存屏障来保证一致性了。lock addl $0x0,(%rsp) 表示把rsp的寄存器的值加0，这显然是一个空操作，关键在于lock前缀。

查看汇编指令中“lock”的说明可知，lock前缀实际上相当于内存屏障，该内存屏障会为指令的执行提供如下几个保障。