Java并发编程实战——volatile

引言

Java 语言提供了一种弱同步机制——volatile 变量。它的作用是确保将变量的更新操作通知到其他线程。

当把变量声明为volatile后，编译器和运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。

另外，volatile变量不会被缓存在寄存器或对其他处理器不可见的地方，因此在读取volatile变量时总是返回最新写入的值。

一、volatile的两个核心作用

volatile 变量是一种比 synchronized 关键字更轻量级的同步机制，这种弱同步机制并不会加锁，它有两方面的作用：

1. 保证线程可见性
2. 禁止指令重排序

可见性指的是共享变量的多线程环境下的变化可以被其他线程所察觉到。在虚拟机中，变量一般存储于堆内存中，线程会在自己的线程空间中拷贝一个变量副本，如果线程修改了变量副本，它需要刷回到公共空间后才，新的值才能够被其他线程获取到，volatile 底层使用了MESI——CPU缓存一致性协议，来实现变量的及时通步。

重排序，在现代CPU架构设计中，往往为了更有效的提升CPU性能，在不影响程序逻辑的前提下，会将一些指令进行重排序。例如单例模式中，new 创建对象时，正常流程发生三个步骤：

1. new 命令分配内存空间，为成员属性设置默认值，如Integer默认为0，这时一种半初始化状态。
2. 为成员属性设置初始值，如静态代码块或一些构造语句
3. 将变量地址分配给引用

但由于指令重拍，第一步已经生成的地址可能会立刻分配给引用，而后执行初始化，即第二和第三步颠倒。

但如果在高并发场景下，单例模式中，如果没有对单例对象增加volatile，这时发生了重排序，在 new 指令完成默认值设置后，其他线程就会判断为非空对象，从而读取一个错误的变量。

二、volatile的典型用法

2.1 循环条件的检查

先看下下面代码：

public class T {
    /*volatile*/ boolean running = true;// 对比一下有无volatile的情况下，整个程序运行结果的区别

    void m() {
        System.out.println("m start...");
        while (running) {
        }
        System.out.println("m end...");
    }

    public static void main(String[] args) {
        T t = new T();
        new Thread(t::m, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.running = false;
    }
}

无volatile运行结果左，有volatile运行结果右：

                           

结果分析

在上面代码中，变量running存在于堆内存的 t 对象中。

当线程 t1 开始运行的时候，会把running值从内存中读到 t1 线程的工作区，在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，在主线程修改running 的值之后，t1 线程忙于执行while死循环（这里有个变式，如果在while循环中加入一些执行的代码，让线程有时间在下一次循环之前读取一下running的值，可能结果会有不同）而感知不到，所以不会停止运行。

使用volatile ，会强制所有线程都去堆内存中读取 running 的值。

这就是一个volatile的典型用法，即检查某个状态标记以判断是否退出循环。

2.2 volatile单例

还有一种用法就是在双重检查逻辑中，volatile 类型的单例，它也可以确保变量的初始化及时被其他线程感知。

参考《Java常用设计模式————单例模式》

2.3 用于操作非原子64位数值变量

另外，64位的数值变量——double、long 在多线程环境下的读取和写入需要添加 volatile。

当线程在没有同步的情况下读取变量，可能会得到一个失效值，但至少是由之前某个线程设置的值，而不是一个无效的随机的值，这种安全保证叫做最低安全性，简单来说就是，虽然并发导致了数据不一致，但最起码还是个旧值，不是无意义的值。

这种最低安全性适用于绝大多数变量，但 64 位的double 和long除外。JVM允许 64 位的读操作或写操作分解为两个32位的操作。以long类型为例，如果对该变量的读和写不在同一个线程，那么可能会读到某个值的高32位和另一个值的低32位。因此，一定记得在多线程环境下操作 double 和 long 时，加上 volatile，或者是 synchronized。

三、无法保证的原子性

volatile与synchronized区别体现在原子性上。

public class T {
    volatile int count = 0;

    void m() {
        for (int i = 0; i < 10000; i++)
            count++;
    }
    
    public static void main(String[] args) {
        T t = new T();
        List<Thread> threads = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t::m, "t" + i));
        }
        threads.forEach((o) -> o.start());

        threads.forEach((o) -> {
            try {
                o.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}

上面代码中，成员变量count 在线程之间可见，10个线程共同完成为count 自加10000的操作，并通过join()方法将10个线程结果合到一起，我们理想的计算结果应该是count 被加了10,0000次（10个线程每个线程加10000次），但是执行结果却是：

                                                    

结果分析

volatile保证了数据的可见性，但是没有保证对数据操作的原子性，也就是说，共享数据可能会因高并发被同一个值覆盖。通俗点解释，多个线程同时改变主内存中的某个值的时候，一个线程改变了这个值，并通知给其他线程及时更新自己线程内缓冲区的副本，但是由于线程改变volatile修饰的变量后需要写入到公共内存中+其他线程再读取，这个过程必然会慢于其他线程写出的速度，导致其他线程还没来得及更新自己副本变量就执行了写出，导致主内存中的数据被覆盖，因此在高并发的情况下不对某个数据的写入加锁，即便设置了volatile可见性，依然会出现问题。

因此，volatile比synchronized速度快很多，所以，如果程序中只需要保证可见性，那就要使用volatile；而如果要同时保证可见性 + 原子性 ，则一定要加锁。

四、解决不一致问题（扩展）

上一节中volatile无法保证原子性，导致最后的结果远远小于10,0000，除了比较常规的将count++ 加锁之外是否有其他的比较好的解决方法呢？

/**
 * 解决同样的问题更高效的方法，是使用AtomicXXX类，
 * AtomicXXX类中的每一个方法都是原子性的，但是不能保证多个方法连续调用是原子性的。
 */
public class T {
//    volatile int count = 0;
    AtomicInteger count = new AtomicInteger(0);
    
    void m() {
        for (int i = 0; i < 10000; i++)
//            count++;
            count.getAndIncrement();
    }
    
    public static void main(String[] args) {
        T t = new T();
        List<Thread> threads = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t::m, "t" + i));
        }
        threads.forEach((o) -> o.start());

        threads.forEach((o) -> {
            try {
                o.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}

上述代码解决了volatile无法保证原子性的问题，使用AtomicXXX类，可以保证其方法操作是原子性的，执行结果如下：

incrementAndGet()方法，可以理解为加了synchronized的count++（保证了count++的原子性），但其实它的实现并不是通过synchronized而是使用了一种系统相当底层的实现，所以AtomicXXX类中方法的效率要比synchronized高很多。所以，对于纯计算的操作，建议使用AtomicXXX类。

总结

A B线程都用到了一个变量，Java默认是A线程中保留一个copy ， 这样如果B 线程修改了该变量，则A线程未必知道。

使用volatile关键字，会让所有线程都会读到变量的修改值。

但是，使用volatile并不能保证在多个线程共同修改共享变量时所带来的不一致问题，也就是说volatile 不能代替 synchronized。

参考：《马士兵-高并发编程》56:35-67:00 + 68:50