搞懂多线程（六）之volatile关键字

一、特性

1.保证可见性

对一个被volatile关键字修改的变量

  • 写操作的话，这个变量的最新值会立即刷新回到主内存中

  • 读操作的话,总是能够读取到这个变量的最新值,也就是这个变量最后被修改的值

  • 当某个线程收到通知,去读取volatile修饰的变量的值的时候,线程私有工作内存的数据失效,需要重新回到主内存中去读取最新的数据。

2.保证有序性（禁止指令重排(后面有说明)）

  • volatile写之前的操作，都禁止排序到volatile之后

  • volatile读之后的操作，都禁止排序到volatile之前

  • volatile写之后volatile读，禁止排序

具体解释

volatile底层通过内存屏障（后面有说明）机制确保有序性

volatile读操作：LoadLoad屏障和LoadStore屏障都在读操作之后

volatile写操作：前面添加StoreStore屏障，后面添加StoreLoad屏障

屏障类型

指令示例

说明

LoadLoad

Load1; LoadLoad; Load2

保证load1的读取操作在load2及后续读取操作之前执行

StoreStore

Store1; StoreStore;Store2

在store2及其后的写操作执行前,保证store1的写操作已刷新到主内存

LoadStore

Load1; LoadStore; Store2

在stroe2及其后的写操作执行前,保证load1的读操作已读取结束

StoreLoad

Store1; StoreLoad; Load2

保证store1的写操作已刷新到主内存之后，load2及其后的读操作才能执行

知识点补充：内存屏障

  • 内存屏障（也称内存栅栏,内存栅障,屏障指令等,是一类同步屏障指令,是CPU或编译器在对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作）,避免代码重排序。内存屏障其实就是一种JVM指令,Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令,通过这些内存屏障指令,volatile实现了Java内存模型中的可见性和有序性,但volatile无法保证原子性

  • 内存屏障之前的所有写操作都要回写到主内存

  • 内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)

  • 一句话:对一个volatile域的写, happens-before于任意后续对这个volatile域的读,也叫写后读

知识点补充：指令重排

编译器优化的重排序：编译器在不改变单线程串行语义的前提下,可以重新调整指令的执行顺序

指令级并行的重排序：处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序

内存系统的重排序：由于处理器使用缓存和读/写缓冲区,这使得加载和存储操作看上去可能是乱序执行

从JMM规范中得知，要满足可见性，有序性，原子性三大特性，那volatile为什么没有原子性呢？

首先看下面原理图

volatile变量具备可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的，也仅是数据加载时是最新的。

但是多线程环境下, 数据计算和数据赋值操作可能多次出现，若数据在加载之后，若主内存volatile修饰变量发生修改之后，线程工作内存中的值将会被赋写掉，操作出现写丢失问题。

由此可见volatile解决的是变量读时的可见性问题，但无法保证原子性,对于多线程修改主内存共享变量的场景必须使用加锁同步。

二、volatile变量的读写过程

Java内存模型中定义的8种每个线程自己的工作内存与主物理内存之间的原子操作

read（读取)-load(加载)-use(使用)-assign(赋值)-store(存储)-write(写入)-lock(锁定)-unlock(解锁)

  • read：作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存

  • load：作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载

  • use：作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作

  • assign：作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作

  • store：作用于工作内存，将赋值完毕的工作变量的值写回给主内存

  • write：作用于主内存，将store传输过来的变量值赋值给主内存中的变量

  • 由于上述6条只能保证单条指令的原子性，针对多条指令的组合性原子保证,没有大面积加锁，所以，JVM提供了另外两个原子指令

  • lock：作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁,就只是锁了写变量的过程

  • unlock：作用于主内存，把一个处于锁定状态的变量释放,然后才能被其他线程占用

三、最佳实践

  1. 单一赋值可以,but含复合运算赋值不可以(i++之类)

volatile int a = 10
volatile boolean flag = false

  1. 状态标志，判断业务是否结束

public class UseVolatileDemo{
    private volatile static boolean flag = true;
    public static void main(String[] args){
        new Thread(() -> {
            while(flag) {
                //do something......
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(2L); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            flag = false;
        },"t2").start();
    }
}

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

public class UseVolatileDemo{
    /**
     * 使用:当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销
     * 理由:利用volatile保证读取操作的可见性;利用synchronized保证复合操作的原子性
     */
    public class Counter{ 
        private volatile int value;
        public int getValue(){
            return value;   //利用volatile保证读取操作的可见性
         }
        public synchronized int increment(){
            return value++; //利用synchronized保证复合操作的原子性
         }
    }
}

  1. 单列模式 DCL双端锁的发布 面试题-->设计模式之单例模式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化，使用volatile关键字来避免指令重排现象
    private static volatile Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            //使用synchronized修饰来避免线程安全问题
            synchronized(Singleton.class){
                if(single == null) {
                    single = new Singleton();
                }
            }
        }
        return single;
    }
}