Java volatile关键字总结

JMM(为什么需要volatile)

Java内存模型(JavaMemoryModel)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量，存储到内存和从内存中读取变量这样的底层细节。

JMM有以下规定：

所有的共享变量都存储于主内存，这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。

每一个变量的工作副本还存在线程的工作(本地)内存中.

线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量。

不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存中转来完成。

本地内存和主内存的关系：

对于普通的共享变量来讲，线程A将其修改为某个值发生在线程A的本地内存中，此时还未同步到主内存中去；而线程B已经缓存了该变量的旧值，所以就导致了共享变量值的不一致。

解决这种共享变量在多线程模型中的不可见性问题，有两种方法：
1.加锁：
某一个线程进入synchronized代码块前后，线程会获得锁，清空工作内存，从主内存拷贝共享变量最新的值到工作内存成为副本，执行代码，将修改后的副本的值刷新回主内存中，线程释放锁。

2.使用volatile

volatile关键字

1.保证此变量对所有线程的可见性

每个线程操作数据的时候会把数据从主内存读取到自己的工作内存，如果他操作了数据并且写会了，他其他已经读取的线程的变量副本就会失效了，需要都数据进行操作又要再次去主内存中读取了。

volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。

注：由于volatile关键字只保证可见性，不保证原子性，我们仍然需要通过加锁(synchronized、lock、java并发包中的原子操作类)来保证原子性。

因为Java里面的运算并非原子操作。
以i++这句代码为例，在多线程的场景下，实际上i++不是原子操作，也就是说，它不是单独一条指令，而是3条指令(3条汇编指令)

1. 从内存中把i的值取出来放到CPU的寄存器中

2. CPU寄存器的值+1

3. 把CPU寄存器的值写回内存

当AB线程读到的i都是0，之后AB为0加1，写回内存，则i做了两次加法，但是实际只加了一个1。

volatile关键字只保证了i的值在取值时是正确的，但无法保证原子性。

2.禁止指令重排序。

重排序是指编译器和处理器为了优化程序性能而对指令序列进行排序的一种手段。重排序需要遵守一定规则：

（1）重排序操作不会对存在数据依赖关系的操作进行重排序。

比如：a=1;b=a; 这个指令序列，由于第二个操作依赖于第一个操作，所以在编译时和处理器运行时这两个操作不会被重排序。

（2）重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执行结果不能被改变

比如：a=1;b=2;c=a+b这三个操作，第一步（a=1)和第二步(b=2)由于不存在数据依赖关系， 所以可能会发生重排序，但是c=a+b这个操作是不会被重排序的，因为需要保证最终的结果一定是c=a+b=3。

使用volatile关键字修饰共享变量便可以禁止这种重排序。若用volatile修饰共享变量，在编译时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序,volatile禁止指令重排序也有一些规则：

a.当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

b.在进行指令优化时，不能将对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

即执行到volatile变量时，其前面的所有语句都执行完，后面所有语句都未执行。且前面语句的结果对volatile变量及其后面语句可见。

例：

//x、y为非volatile变量
//flag为volatile变量
x = 2; //语句1 
y = 0; //语句2 
flag = true; //语句3 
x = 4; //语句4 
y = -1; //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会将语句3放到语句4、语句5后面。但是语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。
并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

原理

volatile可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令，lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

（1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

（2）它会强制将对缓存的修改操作立即写入主存；

（3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

volatile改造单例模式

class Singleton{
    //保证可见性和指令重排
    private volatile static Singleton instence;
    //私有构造
    private Singleton(){};

    private Singleton getInstence(){
        if (instence == null){
            //同步锁定代码块
            synchronized (Singleton.class){
                if (instence == null){
                    //非原子操作
                    instence = new Singleton();
                }
            }
        }
        return instence;
    }
}

对象实际上创建对象要经过过如下几个步骤：

1. 分配内存空间。
2. 调用构造器，初始化实例。
3. 返回地址给引用

所以创建的过程是可能发生指令重排序的，有可能3操作在2之前，此时还没真正的初始化完对象。

但是别的线程去判断instance！= null，直接拿去用了，其实这个对象是个半成品，那就有空指针异常了。