深入理解 java volatile
在开始讲volatile之前,我们需要对以下的内容有所了解.
java 内存模型(JMM)
在java中,java堆内存是存在数据共享的,这些共享数据的通信就是通过java内存模型(JMM)来控制的.
JMM决定一个线程对共享数据的写入何时对另一个线程可见.
JMM是一个抽象的结构,它定义了线程和主内存的关系:
- 线程之间的共享变量存储在主内存(Main Memory)中
- 每一个线程都有一个私有的本地内存(Local Memory)
- 本地内存中储存了该线程可以读写变量的副本.
JMM
- 只有存放在java堆和方法区中的数据,才会被线程共享,对于其他区是属于线程私有的数据,不受JMM的影响.
- 从JMM中可以看出,如果线程之间的数据,是不能直接进行数据传递的,一定要经过主内存进行传递.
- A线程更新数据 -> 刷新主内存数据 -> B线程读取主线程数据
为什么需要JMM?
为什么需要内存模型,直接读写内存不可以吗?
主要是因为下面两个原因.
- CPU缓存一致性
CPU与内存读写和运算速度不在一个量级,CPU效率会比内存高的多.
为了解决CPU和内存效率差异问题,引入了 高速缓存(Cache)和写缓冲区(Write Buffer)等,来作为cpu和内存的传输媒介,使用缓冲中读写可能造成数据不一致的问题.
- 处理器优化和指令重排
处理器优化:处理器为了优化 执行效率, 可能会将输入的代码进行乱序执行处理.
指令重排:JIT编译过程也可能会对指令进行乱序处理 .
为了解决上次两个问题,需要引入JMM,而不是直接操作内存变量。
为了解决 <1>,引入主内存和线程的本地内存概念.
为了解决 <2>,通过 禁止处理器优化, 和 内存屏障来解决.
原子性,可见性,有序性
原子性 : 表示不可被中断的一个或一系列操作.一旦开始，就一直运行到结束，中间不会有任何线程切换(context switch)。
可见性 : 是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值.
有序性 : 由于指令的执行,会经过编译器和处理的重排序,有序性是指从指令上的执行结果上看,指令的执行顺序是有序的.根据as-if-serial语义,单线程中,程序的结果不能被改变.在多线程并发中, 提供 happens-before规则来支持有序性.
volatile
Java语言规范第三版中对volatile的定义如下：
java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。
它被称为轻量级的 synchronized, 它比synchronized的使用和执行成本会更低，因为它不会引起线程上下文的切换和调度。
volatile的特性
- 可见性 : 对一个volatile的变量的读,总是能看到任意线程对这个变量最后的写入.
- 单个读或者写具有原子性 : 对于单个volatile变量的读或者写具有原子性,复合操作不具有.(如i++)
- 互斥性 : 同一时刻只允许一个线程对变量进行操作.(互斥锁的特点)
volatile的内存语义
- volatile的写和锁的释放具有相同的语义,当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存.
- volatile的读和锁的获取有相同的语义,当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。
volatile内存语义的实现
为了实现volatile语义,JMM分为编译器重排序和处理器重排序进行了特殊的处理.
- 针对编译器重排序的处理,有如下规则
volatile重排序规则表
- 针对处理器的重排序,编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序
- 在每个volatile写操作的前面插入一个StoreStore屏障 // 禁止上面的写重排序
- 在每个volatile写操作的后面插入一个StoreLoad屏障 // 禁止上面的写或下面的读/写重排序
- 在每个volatile读操作的后面插入一个LoadLoad屏障 // 禁止下面的读重排序
- 在每个volatile读操作的后面插入一个LoadStore屏障 // 禁止下面的下重排序
volatile的使用条件
- 对变量的写操作不依赖于当前值 或 能够确保只有单一线程能够修改变量的值
如 i++操作,变量的写操作依赖当前值,所以不能保证线程安全.
- 该变量没有包含在具有其他变量的不变式中
如 i<value,即使i变量声明为volatile,也不能保证线程安全,value可能在运行判断的时候发生变化.
正确使用volatile
下面提出几种使用 volatile的场景.
- 状态标志
作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束.
状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换
volatile boolean shutdownRequested;
...
public void shutdown() { shutdownRequested = true; }
public void doWork() {
while (!shutdownRequested) {
// todo...
}
}
- 一次性安全发布（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而不是完成初始化的对象.
对象创建乱序
- 独立观察（independent observation）
将 volatile变量用于多个独立观察结果的发布,是"状态标志"的拓展，该值随时会发生变化，同时会被反复使用，前者一般就是用一次 ;只是简单的赋值操作，不会做复合操作.
class CustomLinkedList{
public volatile Node lastNode;
.....
public void add() {
Node node = new Node();
.....
lastNode = node;//将新节点作为最后一个节点
}
}
- 开销较低的读－写锁策略
当读远多于写，结合使用内部锁和 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(内存屏障)
内存屏障的作用 :
- 阻止屏障两侧的指令重排序
- 强制刷新主内存数据，以及让缓存中相应的数据失效。
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（）方法的开始
