个人理解volatile关键字的作用

转：https://www.cnblogs.com/daxin/p/3364014.html
1. 内存可见性

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。

如果要深入了解volatile关键字的作用，就必须先来了解一下JVM在运行时候的内存分配过程。

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

描述这写交互！

那么在了解完JVM在运行时候的内存分配过程以后，我们开始真正深入的讨论volatile的具体作用

public class VolatileTest extends Thread {
    
    boolean flag = false;
    int i = 0;
    
    public void run() {
        while (!flag) {
            i++;
        }
    }
    
    public static void main(String[] args) throws Exception {
        VolatileTest vt = new VolatileTest();
        vt.start();
        Thread.sleep(2000);
        vt.flag = true;
        System.out.println("stope" + vt.i);
    }
}

上面的代码是通过标记flag来控制VolatileTest线程while循环退出的例子!

下面让我用伪代码来描述一下我们的程序

首先创建 VolatileTest vt = new VolatileTest();
然后启动线程 vt.start();
暂停主线程2秒（Main） Thread.sleep(2000);
这时的vt线程已经开始执行，进行i++;
主线程暂停2秒结束以后将 vt.flag = true;
打印语句 System.out.println(“stope” + vt.i); 在此同时由于vt.flag被设置为true,所以vt线程在进行下一次while判断 while (!flag) 返回假 结束循环 vt线程方法结束退出！
主线程结束
上面的叙述看似并没有什么问题，“似乎”完全正确。那就让我们把程序运行起来看看效果吧，执行mian方法。2秒钟以后控制台打印stope-202753974。

可是奇怪的事情发生了 程序并没有退出。vt线程仍然在运行，也就是说我们在主线程设置的 vt.flag = true;没有起作用。

在这里我需要说明一下，有的同学可能在测试上面代码的时候程序可以正常退出。那是因为你的JVM没有优化造成的！在DOC下面输入 java -version 查看 如果显示Java HotSpot™ … Server 则JVM会进行优化。
如果显示Java HotSpot™ … Client 为客户端模式，需要设置成Server模式 设置方法问Google

问题出现了，为什么我在主线程（main）中设置了vt.flag = true; 而vt线程在进行判断flag的时候拿到的仍然是false?
那么按照我们上面所讲的 “JVM在运行时候的内存分配过程” 就很好解释上面的问题了。

首先 vt线程在运行的时候会把 变量 flag 与 i (代码3,4行)从“主内存” 拷贝到 线程栈内存（上图的线程工作内存）

然后 vt线程开始执行while循环

 while (!flag) {
     i++;
 }

while (!flag)进行判断的flag 是在线程工作内存当中获取，而不是从 “主内存”中获取。

i++; 将线程内存中的i++; 加完以后将结果写回至 “主内存”，如此重复。

然后再说说主线程的执行过程。 我只说明关键的地方

vt.flag = true;

主线程将vt.flag的值同样 从主内存中拷贝到自己的线程工作内存 然后修改flag=true. 然后再将新值回到主内存。

这就解释了为什么在主线程（main）中设置了vt.flag = true; 而vt线程在进行判断flag的时候拿到的仍然是false。那就是因为vt线程每次判断flag标记的时候是从它自己的“工作内存中”取值，而并非从主内存中取值！

这也是JVM为了提供性能而做的优化。那我们如何能让vt线程每次判断flag的时候都强制它去主内存中取值呢。这就是volatile关键字的作用。

再次修改我们的代码

public class VolatileTest extends Thread {
    
    volatile boolean flag = false;
    int i = 0;
    
    public void run() {
        while (!flag) {
            i++;
        }
    }
    
    public static void main(String[] args) throws Exception {
        VolatileTest vt = new VolatileTest();
        vt.start();
        Thread.sleep(2000);
        vt.flag = true;
        System.out.println("stope" + vt.i);
    }
}

在flag前面加上volatile关键字，保证线程每次读取该值的时候都能取到“主内存”中最新的值。在试试我们的程序吧，已经正常退出了。

2.禁止指令重排序优化

为了性能优化，JMM在不改变正确语义的前提下，会允许编译器和处理器对指令序列进行重排序。

有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置）

例如：instance= new Singleton() 并不是一个原子操作，其实际上可以抽象为下面几条JVM指令：

memory =allocate();    //1：分配对象的内存空间 
ctorInstance(memory);  //2：初始化对象 
instance =memory;     //3：设置instance指向刚分配的内存地址

上面操作2依赖于操作1，但是操作3并不依赖于操作2。所以JVM是可以针对它们进行指令的优化重排序的，经过重排序后如下：

memory =allocate();    //1：分配对象的内存空间 
instance =memory;     //3：instance指向刚分配的内存地址，此时对象还未初始化
ctorInstance(memory);  //2：初始化对象

著名的双重检查锁定（double-checked-locking）问题

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null)
                    instance = new Singleton();// 非原子操作
            }
        }

        return instance;
    }
}

双重检查锁定是如何被破坏：

    1.线程 1 进入 getInstance() 方法。
    2.由于 instance 为 null，线程 1 在 //1 处进入synchronized 块。
    3.线程 1 前进到 //3 处，但在构造函数执行之前，使实例成为非null。
    4.线程 1 被线程 2 预占。
    5.线程 2 检查实例是否为 null。因为实例不为 null，线程 2 将instance 引用返回，返回一个构造完整但部分初始化了的Singleton 对象。
    6.线程 2 被线程 1 预占。
    7.线程 1 通过运行 Singleton 对象的构造函数并将引用返回给它，来完成对该对象的初始化。

解决：加上volatile关键字

//注意volatile！！！！！！！！！！！！！！！！！    
private volatile static Singleton instace;     
    
public static Singleton getInstance(){     
    //第一次null检查       
    if(instance == null){              
        synchronized(Singleton.class) {    //1       
            //第二次null检查         
            if(instance == null){          //2    
                instance = new Singleton();//3    
            }    
        }             
    }    
    return instance; 

3.volatile实现原理
　　在生成汇编代码时会在volatile修饰的共享变量进行写操作的时候会多出Lock前缀的指令
　　主要有这两个方面的影响：
　　（１）将当前处理器缓存行的数据写回系统内存；
　　（２）这个写回内存的操作会使得其他CPU里缓存了该内存地址的数据无效　（每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现本地缓存失效后，就会从内存中重读该变量数据）