对volatile关键字的理解

对volatile关键字的理解

问：谈谈你对volatile关键字的理解。
答：volatile是JVM提供的轻量级的同步机制。其作用是：保证可见性，不保证原子性，禁止指令重排（保证有序性）。

1.JMM内存模型（什么是可见性）

 JMM（Java内存模型Java Memory Model，简称JMM）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

JMM关于同步的规定：

1.线程解锁前，必须把共享变量的值刷新回主内存
2.线程加锁前，必须读取主内存的最新值到自己的工作内存
3.加锁解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程如下图：

了解了内存模型之后，即可解释什么是可见性：各个线程在自己的本地内存修改完共享变量副本之后，要写回主内存，并通知其他线程共享变量已经被我修改了，请及时更新。

2.原子性

即不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割。需要整体完整要么同时成功，要么同时失败。

为什么说volatile不保证原子性呢？如何改进使其可以保证原子性呢？代码说明：

/**
 * volatile示例
 */
class MyData2 {
    /**
     * volatile 修饰的关键字，是为了增加 主线程和线程之间的可见性，只要有一个线程修改了内存中的值，其它线程也能马上感知
     */
    volatile int number = 0;
    AtomicInteger number2 = new AtomicInteger();

    //number++多线程下非安全的，会出现写覆盖情况
    public void addPlusPlus() {
        number ++;
    }

    //AtomicInteger在多线程下是线程安全的，因为其使用unsafe类中getAndAddInt方法，自旋锁实现
    public void addPlusPlus2() {
        number2.getAndIncrement();
    }
}

class VolatileAtomicityDemo {

    public static void main(String[] args) {
        MyData2 myData = new MyData2();

        // 创建10个线程，线程里面进行1000次循环
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                // 里面
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                    myData.addPlusPlus2();
                }
            }, String.valueOf(i)).start();
        }

        // 需要等待上面20个线程都计算完成后，在用main线程取得最终的结果值
        // 这里判断线程数是否大于2，为什么是2？因为默认是有两个线程的，一个main线程，一个gc线程
        while(Thread.activeCount() > 2) {
            // yield表示不执行
            Thread.yield();
        }

        // 查看最终的值
        // 假设volatile保证原子性，那么输出的值应该为：  20 * 1000 = 20000
        System.out.println(Thread.currentThread().getName() + "\t finally number value: " + myData.number);
        System.out.println(Thread.currentThread().getName() + "\t finally number2 value: " + myData.number2);
    }
}

number++多线程下非安全的，会出现写覆盖情况,解决办法可以加synchronized关键字，但是这个锁太重了，会影响性能。所以使用AtomicInteger类代替Integer。为啥它就线程安全了？因为其使用unsafe类中getAndAddInt方法，自旋锁原理，这也是CAS（比较和替换）的设计思想，这里先不展开记录。

//自增1
public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
//unsafe类中的底层实现,本质为自旋锁
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

3.禁止指令重排

volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象

什么是指令重排？volatile如何禁止指令重排？

计算机在执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排

一般分以下3种：

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重排序时必须要考虑指令之间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

案例略。

volatile实现禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象

先了解一个概念，内存屏障(Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个:

保证特定操作的执行顺序，
保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。
由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

对volatile变量进行写操作时，会在写操作后加入一条store屏障指令，将工作内存中的共享变量值刷新回到主内存。如下图所示：

对Volatile变量进行读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。如下图所示：

4.volatile的应用

（1）懒汉单例模式代码示例：

class SingletonDemo{
    //懒汉模式
    private static SingletonDemo instance = null;

    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName()+"\t我是构造方法！");
    }

    public static SingletonDemo getInstance() {
        if(null == instance){
            instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

这里启动10个线程访问，结果如下：

所以懒汉单例模式是非线程安全的。

(2)使用volatile关键字的双端检锁机制单例模式（DCL：Double Check Lock）

    //DCL双端校验锁
    private static volatile SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t我是构造方法！");
    }

    public static SingletonDemo getInstance() {
        //判断实例是否为null
        if (null == instance) {
            //加锁
            synchronized(SingletonDemo.class){
                //再确定一遍
                if (null == instance) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }

运行结果：

DCL中volatile解析
volatile关键字防止指令重排在这里发挥了重要的作用,某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。instance = new SingletonDemo();可以分为以下3步完成(伪代码)：

memory = allocate(); //1.分配对象内存空间
instance(memory); //2.初始化对象
instance = memory; //3.设置instance指向刚分配的内存地址，此时instance != null

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。

memory = allocate(); //1.分配对象内存空间
instance = memory;//3.设置instance指向刚分配的内存地址，此时instance! =null，但是对象还没有初始化完成!
instance(memory);//2.初始化对象

但是指令重排只会保证串行语义的执行的一致性(单线程)，但并不会关心多线程间的语义一致性。

所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

参考博文链接：Java开发常见面试题详解（并发，JVM）
参考视频链接：bilibili尚硅谷Java大厂面试题第二季(java面试必学，周阳主讲)