【JUC并发编程】如何正确使用volatile？

前置知识

【JUC并发编程】初识Volatile（概念与特性）

一、概述

Java 语言中的 volatile 变量可以被看作是一种 ”程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。

二、原理

如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，该Lock指令会使这个变量所在缓存行的数据回写到系统内存，根据缓存一致性协议，每个处理器都会通过嗅探在总线上传输的数据来检查自己缓存的值是否已过期，当处理器发现自己的缓存行对应的地址被修改，就会将当前处理器的缓存行设置成无效状态，在下次访问相同内存地址时，强制执行缓存行填充。

三、使用方法

> 单一赋值可以，but含复合运算赋值不可以(i++之类)

volatile int a = 10;
volatile boolean flag = true;

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

使用：作为一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或任务结束
理由：状态标志并不依赖于程序内任何其他状态，且通常只有一种状态转换
例子：判断业务是否结束

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.MILLISECONDS.sleep(2000);}catch(Exception e){e.printStackTrace();}
        new Thread(() -> {
            flag=false;
        }, "t2").start();
    }
}

> 开销较低的读，写锁策略

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

public class UseVolatileDemo {
    public class Counter {
        public volatile int value;

        public int getValue() {
            return value; //利用volatile保证读取操作可见性
        }

        public synchronized int increment() {
            return value++; //利用synchronized保证复合操作的原子性
        }
    }
}

> DCL双端锁的发布

先观看代码

public class SafeDoubleCheckSingleton {
    private static SafeDoubleCheckSingleton singleton;
    //私有化构造方法
    private SafeDoubleCheckSingleton() {
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance() {
        if (singleton == null) {
            //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class) {
                if (singleton == null) {
                    //隐患：多线程环境下，由于该对象可能还未完成初始化就被其他线程获取
                    singleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
        return singleton;
    }
}

单线程看问题代码

单线程环境下 (或者说正常情况下)，在"问题代码处"（创建对象处），会执行如下操作，保证能获取到已完成初始化的实例

多线程看代码问题

隐患： 多线程环境下， 在"问题代码处"，会执行如下操作，由于重排序导致2,3乱序，后果就是其他线程得到的是null而不是完成初始化的对象

解决01：加volatile修饰

private volatile static SafeDoubleCheckSingleton singleton;
//私有化构造方法
private SafeDoubleCheckSingleton() {
}
//双重锁设计
public static SafeDoubleCheckSingleton getInstance() {
    if (singleton == null) {
        //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
        synchronized (SafeDoubleCheckSingleton.class) {
            if (singleton == null) {
                //隐患：多线程环境下，由于该对象可能还未完成初始化就被其他线程获取

                //原理：利用volatile，禁止"初始化对象"（2）和"设置singleton指向内存空间"（3）的重排序
                singleton = new SafeDoubleCheckSingleton();
            }
        }
    }
    //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
    return singleton;
}

解决02：采用静态内部类的方式实现

现在比较好的做法就是采用静态内部内的方式实现

public class SingletonDemo {
    private SingletonDemo(){}
    private static class SingletonDemoHandler{
        private static SingletonDemo instance=new SingletonDemo();
    }
    public static SingletonDemo getInstance(){
        return SingletonDemoHandler.instance;
    }
}