Java当中谈谈你对volatile的理解

1、谈谈你对volatile的理解

volatile是Java虚拟机提供的轻量级的同步机制，是基本上遵守了JMM的规范，主要是保证可见性和禁止指令重排，但并不保证原子性

什么是可见性？

1.1、 我们需要首先了解什么是JMM

1. JMM(Java内存模型Java Memory Model,简称JMM)本身是一种抽象的概念 并不真实存在,它描述的是一组规则或规范通过规范定制了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式
2. 在JMM当中JMM关于同步规定:
   • 线程解锁前,必须把共享变量的值刷新回主内存
   • 线程加锁前,必须读取主内存的最新值到自己的工作内存
   • 加锁解锁是同一把锁
3. 由于JVM运行程序的实体是线程,而每个线程创建时，JVM都会为其创建一个工作内存(有些地方成为栈空间),工作内存是每个线程的私有数据区域,而Java内存模型中规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可访问,但线程对变量的操作(读取赋值等)必须在工作内存中进行,首先要将变量从主内存拷贝到自己的工作空间,然后对变量进行操作,操作完成再将变量写回主内存,不能直接操作主内存中的变量,各个线程中的工作内存储存着主内存中的变量副本拷贝,因此不同的线程无法访问对方的工作内存,此案成间的通讯(传值) 必须通过主内存来完成
4. 简而易见的意思就是开始多个线程中从主内存拷贝值到各自线程的工作内存，若有一个线程改了当前拷贝过来的这个值，并将修改好的值返回给了主内存，那么此时其他线程不知道这个线程已经把值改了，此时必须要有一种机制，只要有一个线程修改完自己的工作内存的值，并写回给主内存以后要及时通知其他线程，这种情况，就是JMM内存模型里面第一个重要特性：俗称：可见性。

计算机存储结构，从本地磁盘到主存到CPU缓存，也就是从硬盘到内存，到CPU。
一般对应的程序的操作就是从数据库查数据到内存然后到CPU进行计算。Java虚拟机规范中试图定义一种Java内存模型来屏蔽掉各种硬件和操作系统的内存访问差异以实现让Java程序在各种平台下都能达到一致的内存访问效果。

1.2、JMM能干嘛？

能干嘛？

• 通过JMM来实现线程和主内存之间的抽象关系。

• 屏蔽各个硬件平台和操作系统的内存访问差异以实现让Java程序在各种平台下都能达到一致的内存访问效果

JMM定义了线程和主内存之间的抽象关系
1 线程之间的共享变量存储在主内存中(从硬件角度来说就是内存条)
2 每个线程都有一个私有的本地工作内存，本地工作内存中存储了该线程用来读/写共享变量的副本(从硬件角度来说就是CPU的缓存，比如寄存器、L1、L2、L3缓存等)

1.3、什么是原子性？

• 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。即要么同时成功，要么同时失败

为什么volatile不能保证原子性？

• 在我们进行i++的时候 当在多线程的环境下，线程A现在增加变为3，此时B线程为2 ，C线程为1。在这一刻，有可能B线程抢先一步操作完成再并且将变量写回到了主内存当中。因为当主内存发生了变化，所有其他线程就会被通知。所有现在A和C线程需要重新将主内存值拷贝到各自线程的工作内存。这是就出现了值被覆盖。

如何解决原子性？

• 可以使用java.util.concurrent.atomic包下的AtomicInteger(带原子性包装的整型类)来解决不保证原子性问题

1.4、什么是禁止指令重排？

• 计算机在执行程序时,为了提高性能,编译器和处理器常常会做指令重排， 重排序是指编译器和处理器为了优化程序性能而对指令序列进行排序的一种手段。但在多线程的环境下，,由于编译器优化重排的存在，有可能使用的变量是否能保持一致性是无法确定的,结果无法预测。所以volatile的有序性能帮助我们避免这种情况发生

所谓的禁止指令重排也指的是有序性

---

对于一个线程的执行代码，我们总是习惯性的认为代码的执行总是从上到下，有序执行。

但为了提供性能，编译器和处理器通常会对指令序列进行重新排序。

指令重排可以保证串行语义的一致性,但没有义务保证多线程间的语义也一致，即可能产生”脏读“，简单的来说：两行以上不相干的代码在执行的时候有可能先执行的不是第一条，不见得事从上到下的顺序执行，执行顺序会被优化。

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

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

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

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
class MyData{
    volatile int number = 0 ;

    //验证可见性
    public void addT060(){
        this.number = 60 ;
    }

    //加了volatile 不能确保原子性
    public void addPlusPlus(){
        number++;
    }


    //解决原子性问题
    AtomicInteger atomicInteger =new AtomicInteger();

    public void addMyAtomic(){
        atomicInteger.getAndIncrement();
    }
}
public class volatileDemon {
    public static void main(String[] args) {
        MyData myData = new MyData();
        for(int i = 1;i <=20;i++ ){
            new Thread(()->{
                for (int j = 1; j <1000 ; j++) {
                    myData.addPlusPlus();
                       myData.addMyAtomic();
                }
            }, String.valueOf(i)).start();
        }
        //等待上面线程计算完成，再用main线程取得最终的结果值 看看是多少？
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number:" + myData.number);
        System.out.println(Thread.currentThread().getName()+"\t AtomicInteger:" + myData.atomicInteger);
    }

    //验证可见性
    private static void MyNumber(MyData myData) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t come in");
            //暂停一会线程
            try { TimeUnit.SECONDS.sleep(3 );} catch (InterruptedException e) { e.printStackTrace(); }
            myData.addT060();
            System.out.println(Thread.currentThread().getName()+"\t update AAA  value "+myData.number);
        },"AAAA").start();
        //第二个主线程就是我们主线程
        while (myData.number == 0){
            //main线程就通过Thread类自带的中断api方法实现一直等待 直到number 不为 0 了
        }
        System.out.println(Thread.currentThread().getName()+"\t is over "+myData.number);
    }
}

在哪些地方用到过volatile?

• 在单例模式中，DCL(双端检锁) 机制不一定线程安全,原因是有指令重排的存在,加入volatile可以禁止指令重排
• AtomicReferenceFieldUpdater（原子更新引用类型字段的值)

public class SingleDemo {

    private volatile static SingleDemo instance = null;

    private SingleDemo(){
        System.out.println(Thread.currentThread().getName()+"/t SingleDemo的构造方法");
    }

    public static SingleDemo getInstance(){
       if (instance==null) {
           synchronized (SingleDemo.class) {
               if (instance == null) {
                   instance = new SingleDemo();
               }
           }
       }
       return instance;
    }

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

1.5、内存屏障

首先我们需要知道volatile凭什么可以保证可见性和有序性？？？-----》内存屏障 (Memory Barriers / Fences)

在JVM中为我们提供了四类内存屏障指令（底层原理为C++ Unsafe.cpp）,在我们之前先了解happens-before之volatile变量规则

• 当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前。

• 当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后。

• 当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。

1. 在每个 volatile 写操作的前⾯插⼊⼀个 StoreStore 屏障
   • StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。
2. 在每个 volatile 写操作的后⾯插⼊⼀个 StoreLoad 屏障
   • StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序
3. 在每个 volatile 读操作的后⾯插⼊⼀个 LoadLoad 屏障
   • LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序
4. 在每个 volatile 读操作的后⾯插⼊⼀个 LoadStore 屏障
   • LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序

想了解的更清楚的话，推荐一下尚硅谷周阳老师的JUC相关课程。讲的非常不错滴