深入理解 java volatile

  1. 云栖社区>
  2. 博客>
  3. 正文

深入理解 java volatile

jimmie_yang 2018-10-13 10:46:00 浏览479
展开阅读全文

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

java 内存模型(JMM)

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

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

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

  1. 线程之间的共享变量存储在主内存(Main Memory)中
  2. 每一个线程都有一个私有的本地内存(Local Memory)
  3. 本地内存中储存了该线程可以读写变量的副本.
img_d19b888afa20201c501ea729a0512b99.png
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. 针对编译器重排序的处理,有如下规则
img_48c065fe227ac8f024d4a85d40fc20dd.png
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;
    }
}

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

img_a98d176aff05fd005ed06a26d8eb841e.png
对象创建顺序

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

img_0af7f2e3bbf99ab8dfcbfebca6bb7f60.png
对象创建乱序
  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

img_6a7e48a937f23aff3606dd5ffa36c08c.png
内存屏障类型表

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 变量

网友评论

登录后评论
0/500
评论
jimmie_yang
+ 关注