Java 并发编程—volatile 关键字

volatile 关键字

volatile 作用

volatie 用于修饰变量，它有两个作用。

• 它可以保证变量在多线程之间是可见的，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
• 禁止指令重排序。

volatile 保证变量的可见性

先来看一下 volatile 保证变量在线程之间的可见性问题，在下面这段代码中，isContinuePrint共享变量，printThread 这个线程体中使用这个while (isContinuePrint)来判断是否要继续执行。如果在其他线程中将标记修改为 false 的话，printThread会跳出 while 循环吗？

public class PrintString implements Runnable {
    private boolean isContinuePrint = true;
    @Override
    public void run() {

        while (isContinuePrint) {
            System.out.println(Thread.currentThread().getName() + " print running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+" end..");
    }
    public void setContinuePrint(boolean continuePrint) {
        isContinuePrint = continuePrint;
    }


    public static void main(String[] args) {
        PrintString printString = new PrintString();
        Thread printThread = new Thread(printString);
        printThread.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在主线程停止
        printString.setContinuePrint(false);
        System.out.println(Thread.currentThread().getName() + " end");
    }
}

在大多数执行结果来是可以跳出循环的，但是这里面是有问题的。我们可以将上面的代码简化为以下伪代码

private boolean isContinuePrint = true;
//线程1
while(isContinuePrint){
    //噼里啪啦执行
}

//线程2
isContinuePrint = false

线程1先开始执行，然后线程2再执行。在一段时间后，线程2将isContinuePrint设置为 false，这时线程2的isContinuePrint如果还没有来得及写入到主存中，CPU 就去执行线程1，这时线程1得到的值还是true，那么就不会跳出循环了。

我们使用 volatile 在修饰 isContinuePrint 就可以解决这个问题了。

private volatile boolean isContinuePrint = true;

volatile 能保证变量被一个线程2修改后，会立即将数据写入到主存中，并且线程1中缓存的变量无效，这样线程1去读取这个变量时就能得到一个最新的值。

volatile能保证原子性吗？

什么是原子性操作？

对于共享资源一步或者多步的操作是不会被中断执行的，这种操作过程就是原子性操作，将整个操作视为一个整体，这是原子性操作的核心特征。

验证 volatile 不能保证原子性操作

volatile 是不能保证多线程对共享资源操作的原子性的，下面通过一个栗子的证明：

它的执行结果是会是 200 吗？

public class NoAtomicPersonCount implements Runnable {
    private int personCount = 0;
    public static void main(String[] args) {
        NoAtomicPersonCount waiter = new NoAtomicPersonCount();
        Thread person1 = new Thread(waiter);
        Thread person2 = new Thread(waiter);

        person1.start();
        person2.start();
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            personCount++;
        }
        //它的执行结果是会是 200 吗？
        System.out.println(Thread.currentThread().getName() + "-人数：" + personCount);

    }
}

答案是不一定会是200。因为在多个线程下对personCount进行累加操作。而 personCount++ 它并不是一个原子性操作，因此在多线程环境下，就会出现数据错误问题。

personCount++ 在内存中的操作过程如下：

• 线程person1 读取了 personCount 的值0，这时线程person1工作内存就保存了 personCount 的值为 0。这时 CPU 的执行权被 线程person2 抢走了，这时 线程person1 就阻塞了。
• 线程person2读取主存中的 personCount 此时值为 0，因为 线程person1 只是读取了personCount，并没有修改这个值，因此不会导致 线程person2 中的缓存失效，然后线程person2 对 personCount 进行累加然后写入到主存的值为1中。
• 到了 线程person1 执行时，由于在第一步中已经将 personCount 读取到本地内存中，因此不会再去主存中读取了，这时进行累加得到值是 personCount 的值为 1。
• 此时 线程person1和线程person2操作得到的值都是1，这就出现了线程安全问题。

针对上面的栗子，这里使用一个草图来描述一下为什么 volatile 不能保证原子性。

volatile能保证有序性吗？

在前面介绍 volatile 的作用时，提到的第二个点，禁止指令重排序。

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

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

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

这里以 DCL 的单例设计模式来分析 volatile 的有序性问题

public class Singleton {
   private static Singleton instance = null;
   private Singleton() {}
 
   public static Singleton getInstance() {
        
        if (instance == null){//A
            synchronized(Singleton.class){//B
                if (instance == null)//C
                    instance = new Singleton();//D
                }
        }
        return instance;
   }
}

• 线程1调用 getInstance() 获取锁，执行到了 D 位置，执行 Singleton()对象的创建。

• Singleton()对象的创建按照顺序分为以下3个步骤：

  • 在内存中分配地址。
  • 执行构造函数对对象初始化。
  • 将内存空间地址赋值给该引用变量instance。

这里如果 JVM 对指令优化，导致第2步和第3部的执行顺序相反

• 在内存中分配地址。
• 将内存空间地址赋值给该引用变量instance。
• 执行构造函数对对象初始化。

这时线程1先执行将内存空间地址赋值给该引用变量，但是还没有来得及执行构造函数对对象初始化，CPU 执行权被线程2抢去了。

• 线程2调用 getInstance() 方法执行到 A 位置，这时发现 instance 不为空，此时返回是 instance ，这个 instance 此时还没有执行执行构造函数对对象初始化这一步操作，所以在使用instance时就会出现问题。

解决这个指令重拍序问题，可以给 instance 变量使用 volatile 修饰。

private static volatile Singleton instance = null;

volatile 能保证 Singleton 对象的创建一定是按照以下步骤执行的。

• 在内存中分配地址。
• 执行构造函数对对象初始化。
• 将内存空间地址赋值给该引用变量instance。

总结

本文总结了 volatile 的两个作用，分别是保证共享变量在多线程之间是可见的和禁止指令重排序，并分别用实例来验证了 volatile 的特性。本文是笔者学习之后的总结，方便日后查看学习，有任何不对的地方请指正。

记录于2019年4月14日