深入理解 java volatile

在开始讲volatile之前,我们需要对以下的内容有所了解.

java 内存模型(JMM)

在java中,java堆内存是存在数据共享的,这些共享数据的通信就是通过java内存模型(JMM)来控制的.

JMM决定一个线程对共享数据的写入何时对另一个线程可见.

JMM是一个抽象的结构,它定义了线程和主内存的关系:

1. 线程之间的共享变量存储在主内存(Main Memory)中
2. 每一个线程都有一个私有的本地内存(Local Memory)
3. 本地内存中储存了该线程可以读写变量的副本.

JMM

• 只有存放在java堆和方法区中的数据,才会被线程共享,对于其他区是属于线程私有的数据,不受JMM的影响.
• 从JMM中可以看出,如果线程之间的数据,是不能直接进行数据传递的,一定要经过主内存进行传递.
  • A线程更新数据 -> 刷新主内存数据 -> B线程读取主线程数据

为什么需要JMM?

为什么需要内存模型,直接读写内存不可以吗?

主要是因为下面两个原因.

1. CPU缓存一致性

CPU与内存读写和运算速度不在一个量级,CPU效率会比内存高的多.
为了解决CPU和内存效率差异问题,引入了 高速缓存(Cache)和写缓冲区(Write Buffer)等,来作为cpu和内存的传输媒介,使用缓冲中读写可能造成数据不一致的问题.

1. 处理器优化和指令重排

处理器优化:处理器为了优化 执行效率, 可能会将输入的代码进行乱序执行处理.
指令重排:JIT编译过程也可能会对指令进行乱序处理 .

为了解决上次两个问题,需要引入JMM,而不是直接操作内存变量。

为了解决 <1>,引入主内存和线程的本地内存概念.
为了解决 <2>,通过 禁止处理器优化, 和 内存屏障来解决.

原子性,可见性,有序性

原子性 : 表示不可被中断的一个或一系列操作.一旦开始，就一直运行到结束，中间不会有任何线程切换(context switch)。

可见性 : 是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值.

有序性 : 由于指令的执行,会经过编译器和处理的重排序,有序性是指从指令上的执行结果上看,指令的执行顺序是有序的.根据as-if-serial语义,单线程中,程序的结果不能被改变.在多线程并发中, 提供 happens-before规则来支持有序性.

volatile

Java语言规范第三版中对volatile的定义如下：

java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。

它被称为轻量级的 synchronized, 它比synchronized的使用和执行成本会更低，因为它不会引起线程上下文的切换和调度。

volatile的特性

1. 可见性 : 对一个volatile的变量的读,总是能看到任意线程对这个变量最后的写入.
2. 单个读或者写具有原子性 : 对于单个volatile变量的读或者写具有原子性,复合操作不具有.(如i++)
3. 互斥性 : 同一时刻只允许一个线程对变量进行操作.(互斥锁的特点)

volatile的内存语义

• volatile的写和锁的释放具有相同的语义,当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存.
• volatile的读和锁的获取有相同的语义,当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

volatile内存语义的实现

为了实现volatile语义,JMM分为编译器重排序和处理器重排序进行了特殊的处理.

1. 针对编译器重排序的处理,有如下规则

volatile重排序规则表

1. 针对处理器的重排序,编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序

• 在每个volatile写操作的前面插入一个StoreStore屏障 // 禁止上面的写重排序
• 在每个volatile写操作的后面插入一个StoreLoad屏障 // 禁止上面的写或下面的读/写重排序
• 在每个volatile读操作的后面插入一个LoadLoad屏障 // 禁止下面的读重排序
• 在每个volatile读操作的后面插入一个LoadStore屏障 // 禁止下面的下重排序

volatile的使用条件

1. 对变量的写操作不依赖于当前值 或 能够确保只有单一线程能够修改变量的值

如 i++操作,变量的写操作依赖当前值,所以不能保证线程安全.

1. 该变量没有包含在具有其他变量的不变式中

如 i<value,即使i变量声明为volatile,也不能保证线程安全,value可能在运行判断的时候发生变化.

正确使用volatile

下面提出几种使用 volatile的场景.

1. 状态标志

作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束.

状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换

volatile boolean shutdownRequested;
 
...
 
public void shutdown() { shutdownRequested = true; }
 
public void doWork() { 
    while (!shutdownRequested) { 
        // todo...
    }
}

1. 一次性安全发布（one-time safe publication）

在缺乏同步的情况下，可能会遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在。（这就是造成著名的双重检查锁定（double-checked-locking）问题的根源）。

//基于volatile的解决方案
public class SafeDoubleCheckSingleton {
    //通过volatile声明，实现线程安全的延迟初始化
    private volatile static SafeDoubleCheckSingleton singleton;
    private SafeDoubleCheckSingleton(){
    }
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    //原理利用volatile在于 禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序
                    singleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        return singleton;
    }
}

由于对象的创建,可以拆分成以下指令:

对象创建顺序

在多线程环境中,如果没有对变量 声明为volatile,将可能出现以下情况,其他线程可能得到的是null而不是完成初始化的对象.

对象创建乱序

1. 独立观察（independent observation）

将 volatile变量用于多个独立观察结果的发布,是"状态标志"的拓展，该值随时会发生变化，同时会被反复使用，前者一般就是用一次 ;只是简单的赋值操作，不会做复合操作.

class CustomLinkedList{
    public volatile Node lastNode;
    .....
    public void add() {
        Node node = new Node();
        .....
        lastNode = node;//将新节点作为最后一个节点
    }
}

1. 开销较低的读－写锁策略

当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销
利用volatile保证读取操作的可见性；利用synchronized保证复合操作的原子性

public class Counter {
    private volatile int value;
    //利用volatile保证读取操作的可见性, 读取时无需加锁
    public int getValue() { return value; }
    // 使用 synchronized 加锁
    public synchronized int increment() { 
        return value++;
    }
}

参考

memory barriers(内存屏障)

内存屏障的作用 :

1. 阻止屏障两侧的指令重排序
2. 强制刷新主内存数据，以及让缓存中相应的数据失效。

java的内存屏障有的四种,LoadLoad,StoreStore,LoadStore,StoreLoad

内存屏障类型表

as-if-serial

as-if-serial的语义是, 不管怎么重排序,单线程中程序的执行结果不能被改变. 编译器,runtime,处理器都需要遵守该语义.

happens-before

• 程序顺序原则：一个线程内保证语义的串行性.对于单线程来讲，必须保证重排后的结果与重排前一致。
• volatile规则：volatile变量的写，先发生于后续对这个变量的读.这保证了volatile变量的可见性.
• 监视锁规则：对于一个锁的解锁,先发生于随后对这个锁的加锁. 否则随后的加锁将会失败.
• 传递性：A先于B，B等于C，那么A必然先于C.
• 线程启动规则：Thread对象的start（）方法先发生于此线程的其他任意动作。
• 线程终止规则：线程的所有操作都先发生于对此线程的终止检测，可以通过Thread.join（）方法结束、Thread.isAlive（）的返回值等手段检测到线程已经终止执行。
• 线程中断规则：对线程interrupt（）方法的调用先发生于被中断线程的代码检测到中断时事件的操作。
• 对象终结规则：一个对象的初始化完成（构造函数执行结束）先发生于它的finalize（）方法的开始

引用

1. java并发编程的艺术
2. 并发番@Java内存模型&Volatile一文通（1.7版）
3. 正确使用 Volatile 变量