深入理解Volatile关键字

1.概念

volatile是Java虚拟机提供的轻量级的同步机制;

而相对应重量级同步机制就是synchronized;

2.三个特性

保证可见性

可见性就是当主内存中变量被某一个线程修改后刷新到主内存，会立即通知其他线程该变量已经被修改。

不保证原子性

原子性：不可分割，完整性，要么同时成功，要么失败。
保证数据的一致性！！！

禁止指令重排

指令重排：
源代码->编译器优化的重排->指令并行的重排->内存系统的重排->最终执行的指令
处理器在进行重排序时必须考虑指令之间的数据依赖性。如果存在数据依赖性，则编译器不发生指令重排。

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

3.JMM

jmm是java内存模型，是一种约定形成的规范，本身并不存在；规范定义了程序中各个变量（包括实例字段、静态字段、和数组对象）。

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

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

各个线程对主内存***享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回主内存中的。

3.1JMM三个特性

可见性

Volatile可以解决这个可见性问题；

class MyData{//MyData.java ===> MyData.class --->jvm字节码

    volatile int number = 0;
    public void addTo60(){
        this.number = 60;
    }
 }
 public  class Demo(){
	//volatile保证可见性
    private static void seeOkVolatile() {
        MyData myData = new MyData();
        //线程AAA操作
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t come in");
            //暂停一会线程
            try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
            
            myData.addTo60();
            System.out.println(Thread.currentThread().getName()+"\t update value:"+myData.number);
        },"AAA").start();

        //第2个线程就是我们的main线程

        while(myData.number == 0){
            //main线程就一直在这里等待循坏，直到number不为0

        }

        System.out.println(Thread.currentThread().getName()+"\t mission is over:"+myData.number);
    }    
}

原子性

利用JUC的AtomicInteger原子类解决或者重量级synchronized

class MyData{//MyData.java ===> MyData.class --->jvm字节码

    volatile int number = 0;
 //请注意，此时已经加了关键字volatile,不保证原子性
    public  void  addPlusPlus(){
        number++;
    }

    AtomicInteger atomicInteger = new AtomicInteger();

    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}

public class VolatileDemo {
    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.addAtomic();
                }
            },String.valueOf(i)).start();
        }
        //需要等待上面20个线程全部计算完成后，再用main接受结果20000
        //默认线程1是main，线程2是GC线程
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.number);
        System.out.println(Thread.currentThread().getName()+"\t finally number value:"+myData.atomicInteger);
    }
   }

有序性

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

内存屏障又称内存栅栏，是一个CPU指令，它的作用有两个：
一是保证特定操作的执行顺序
二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

1、由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条内存屏障则告诉编译器和CPU，不管什么指令都不能和这条内存屏障指令重新排序；
2、也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化；
3、内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

4.哪些地方用到Volatile？

DCL（双端检锁）机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排。

public class SingletonDemo {

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

     //DCL （Double check lock双端检锁机制）
     //原本单线程是：
     1.上厕所发现门没锁，应该是null
     2.拿锁子把门锁起来synchronized
     3.检查一下门是否锁住了，应该是null
     //实际上多线程有可能是：
     1.先拿锁子把门锁住synchronized
     2.再去上厕所看门锁住了没
     3.发现门锁了，实际里面却没人---这是我们不希望看到的结果
     //原因在于：
     原因在于某一个线程执行到第一个检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。
     public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
     }

    public static void main(String[] args) {
        //单线程main
        /*System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(); System.out.println(); System.out.println();*/
        //多线程并发

        for(int i = 1;i <=10;i++){
            new Thread(()->{
                SingletonDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}

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

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

总结

1.工作内存和主内存同步延迟现象导致的可见性问题
可以使用synchronized或volatile关键字解决，他们都可以使一个线程修改后的变量立即对其他线程可见。

2.对于指令重排导致的可见性问题和有序性问题
可以利用volatile关键字解决，因为volatile的另外一个作用就是禁止重排序优化。