java并发(4)深入理解volatile

知识基础

需要先了解 Java内存模型相关知识.

定义

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

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

一句话即, volatile 声明的变量可以保证多线程对这个变量的可见性.

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

volatile的内存语义

回顾下happens-before对volatile规则的定义 : volatile变量的写，先发生于后续对这个变量的读.

这句话的含义有两层.

volatile 的写操作, 需要将线程本地内存值,立马刷新到主内存的共享变量中.
volatile 的读操作, 需要从主内存的共享变量中读取,更新本地内存变量的值.

由此引出 volatile 的内存语义.

当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存.
当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量,并更新本地内存的值.

volatile 的特性

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

所以说, 对于单步操作的 volatile 具有锁的特点.

class VolatileFeaturesTest1 {
    private volatile long vl = 0L;          // 使用volatile声明64位的long型变量

    public void set(long l) {
        vl = l;                             // 单个volatile变量的写
    }

    public void getAndIncrement() {
        vl++;                               // 复合（多个）volatile变量的读/写
    }

    public long get() {
        return vl;                          // 单个volatile变量的读
    }
}

class VolatileFeaturesTest2 {
    long vl = 0L;                           // 64位的long型普通变量

    public synchronized void set(long l) {  // 对单个的普通变量的写用同一个锁同步
        vl = l;
    }

    public void getAndIncrement() {         // 普通方法调用
        long temp = get();                  // 调用已同步的读方法
        temp += 1L;                         // 普通写操作
        set(temp);                          // 调用已同步的写方法
    }

    public synchronized long get() {        // 对单个的普通变量的读用同一个锁同步
        return vl;
    }
}
// 上诉两个类效果是等价的.

volatile 内存语义的实现

JMM为volatile定制的重排序规则:

volatile重排序规则.png

从表中归纳.

当第一个操作是 volatile读时,不管第二个操作是什么,都不能重排序.确保volatile读之后的操作不会被重排序到 volatile读之前.
当第二个操作是 volatile写时,不管第一个操作是什么,都不能重排序.确保volatile写之前的操作不会被重排序到volatile写之后.
当第一个操作是 volatile写,第二个操作是 volatile读时,不能重排序.

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

在每个volatile写操作的前面插入一个StoreStore屏障。
在每个volatile写操作的后面插入一个StoreLoad屏障。
在每个volatile读操作的后面插入一个LoadLoad屏障。
在每个volatile读操作的后面插入一个LoadStore屏障。

volatile写内存屏障

volatile写内存屏障.png

StoreStore屏障 可以保证在volatile写之前，其前面的所有普通写操作已经对任
意处理器可见了。

StoreLoad屏障 将 volatile写操作刷新到内存.

由此达到, volatile写立马刷新到主内存的效果.

volatile读内存屏障

volatile读内存屏障.png

LoadLoad屏障 保障后续是读操作时, volatile读装载到内存数据.
LoadStore屏障 保障后续是写操作时, volatile读装载到内存数据.

由此达到, volatile读从主内存中读取共享变量,并更新本地内存的值.

volatile的使用条件

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

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

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

如 i,即使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++;
    }
}
 
 引用 
  
  java并发编程的艺术 
  并发番@Java内存模型&Volatile一文通（1.7版） 
  正确使用 Volatile 变量