初识volatile关键字

jiezi

5 年前

上次我们已经学习了 Synchronized 关键字，有兴趣的可以看看：死磕 Synchronized 实现原理，今天来研究一下 volatile 关键字，主要有以下知识点：

并发编程中的三个概念
深入剖析 volatile 关键字
volatile 的原理和实现机制
使用 volatile 关键字的场景

在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。

一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

一个很经典的例子就是银行账户转账问题：比如从账户 A 向账户 B 转 1000 元，那么必然包括 2 个操作：从账户 A 减去 1000 元，往账户 B 加上 1000 元。试想一下，如果这 2 个操作不具备原子性，会造成什么样的后果。假如从账户 A 减去 1000 元之后，操作突然中止。这样就会导致账户 A 虽然减去了 1000 元，但是账户 B 没有收到这个转过来的 1000 元。所以这 2 个操作必须要具备原子性才能保证不出现一些意外的问题。

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

举个简单的例子，看下面这段代码：

 // 线程 1 执行的代码
 int i = 0;
 i = 10;
 
 // 线程 2 执行的代码
 j = i;

假若执行线程 1 的是 CPU1，执行线程 2 的是 CPU2。当线程 1 执行 i = 10 这句时，会先把 i 的初始值加载到 CPU1 的高速缓存中，然后赋值为 10，那么在 CPU1 的高速缓存当中 i 的值变为 10 了，却没有立即写入到内存当中。此时线程 2 执行 j = i，它会先去内存读取 i 的值并加载到 CPU2 的缓存当中，注意此时内存当中 i 的值还是 0，那么就会使得 j 的值为 0，而不是 10。
这就是可见性问题，线程 1 对变量 i 修改了之后，线程 2 没有立即看到线程 1 修改的值。

程序执行的顺序按照代码的先后顺序执行。

首先解释一下什么是 指令重排序 ，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

// 线程 1:
context = loadContext();   // 语句 1
inited = true;             // 语句 2
 
// 线程 2:
while(!inited){sleep()
}
doSomethingwithconfig(context);

上面代码中，由于语句 1 和语句 2 没有数据依赖性，因此可能会被重排序。
假如发生了重排序，在线程 1 执行过程中先执行语句 2，而此时线程 2 会以为初始化工作已经完成，
那么就会跳出 while 循环，去执行 doSomethingwithconfig(context)方法，而此时 context 并没有被初始化，就会导致程序出错。

从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。
也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

volatile 所修饰的变量是直接存在于主内存中的。
JMM 中的内存分为主内存和工作内存，其中主内存是所有线程共享的。而工作内存是每个线程独立分配的，各个线程的工作内存之间相互独立、互不可见。
在线程启动的时候，JVM 为每个内存分配了一块工作内存，不仅包含了线程内部定义的局部变量，也包含了线程所需要的共享变量的副本，当然这是为了提高执行效率，读副本的比直接读主内存更快。

即线程 A 对 volatile 变量的修改，其他线程获取的 volatile 变量都是最新的。
对于 volatile 修饰的变量 (共享变量) 来说，在工作内存发生了变化后，必须要马上写到主内存中，而线程读取到是 volatile 修饰的变量时，必须去主内存中去获取最新的值 ，而不是读工作内存中主内存的副本，这就有效的保证了线程之间变量的 可见性。

那么什么是指令重排序?
为了尽可能减少内存操作速度远慢于 CPU 运行速度所带来的 CPU 空置的影响，虚拟机会按照自己的一些规则将程序编写顺序打乱。

volatile 可以保证线程的可见性和有序性，但没办法保证对变量的操作的原子性。

在 Java 中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

请分析以下哪些操作是原子性操作：

  x = 10;        // 语句 1
  y = x;         // 语句 2
  x++;           // 语句 3
  x = x + 1;     // 语句 4

只有语句 1 是原子性操作，其他三个语句都不是原子性操作。

语句 1 是直接将数值 10 赋值给 x，也就是说线程执行这个语句的会直接将数值 10 写入到工作内存中。
语句 2 实际上包含 2 个操作，它先要去读取 x 的值，再将 x 的值写入工作内存，虽然读取 x 的值以及将 x 的值写入工作内存这 2 个操作都是原子性操作，但是合起来就不是原子性操作了。
同样的，x++ 和 x = x+ 1 包括 3 个操作：读取 x 的值，进行加 1 操作，写入新的值。

下面看一个例子：

public class Test {
    public volatile int inc = 0;
     
    public void increase() {inc++;}
     
    public static void main(String[] args) {final Test test = new Test();
        for(int i=0;i<10;i++){new Thread(){public void run() {for(int j=0;j<1000;j++)
                        test.increase();};
            }.start();}
         
        while(Thread.activeCount()>1)  // 保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

事实上运行它会发现每次运行结果都不一致，都是一个小于 10000 的数字。上面的程序错在没能保证原子性。

下面这段话摘自《深入理解 Java 虚拟机》：
观察加入 volatile 关键字和没有加入 volatile 关键字时所生成的汇编代码发现，加入 volatile 关键字时，会多出一个 lock 前缀指令。
lock 前缀指令实际上相当于一个 内存屏障，内存屏障会提供 3 个功能：

它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

它会强制将对缓存的修改操作立即写入主存；

如果是写操作，它会导致其他 CPU 中对应的缓存行无效。

synchronized 关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而 volatile 关键字在某些情况下性能要优于 synchronized，但是要注意volatile 关键字是无法替代 synchronized 关键字的，因为 volatile 关键字无法保证操作的原子性。

通常来说，使用 volatile 必须具备以下 2 个条件：

对变量的写操作不依赖于当前值
该变量没有包含在具有其他变量的不变式中

事实上，我的理解就是上面的 2 个条件需要保证操作是原子性操作，才能保证使用 volatile 关键字的程序在并发时能够正确执行。

volatile 关键字

初识volatile关键字

并发编程中的三个概念

`原子性`

`可见性`

`有序性`

深入剖析 volatile 关键字

性质

volatile 特性

`内存可见性`

`可以禁止指令重排序`

volatile 能保证原子性吗？

volatile 的原理和实现机制

使用 volatile 关键字的场景

参考