深入解析Volatile关键字 及 Java的内存模型

一、Java的内存模型

Java内存模型规定了所有的变量都存储在主内存中
每条线程中还有自己的工作内存，线程的工作内存中保存了被该线程所使用到的变量（这些变量是从主内存中拷贝而来）。
线程对变量的所有操作（读取，赋值）都必须在工作内存中进行。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。

基于此种内存模型，便产生了多线程编程中的数据“脏读”等问题。
例子：i = 10++;

执行线程必须先在自己的工作线程中对变量i所在的缓存行进行赋值操作，然后再写入主存当中。而不是直接将数值10写入主存当中。
比如同时有2个线程执行这段代码，假如初始时i的值为10，那么我们希望两个线程执行完之后i的值变为12。但是事实会是这样吗？
可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的工作内存当中，然后线程1进行加1操作，然后把i的最新值11写入到内存。此时线程2的工作内存当中i的值还是10，进行加1操作之后，i的值为11，然后线程2把i的值写入内存。
在解决这个问题之前，我们要先了解并发编程的三大概念：原子性，有序性，可见性。

二、并发编程的三大概念：原子性，有序性，可见性

1、原子性

1、定义

即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。例如银行转账

2、Java中的原子性

对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。只有简单的读取、赋值（而且必须是将数字赋值给某个变量，
变量之间的相互赋值不是原子操作）才是原子操作。

例子：
x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4
只有语句1是原子性操作，其他三个语句都不是原子性操作。  
语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及
将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。

2、可见性

1、定义

当多个线程访问同一个变量，有一个线程对该变量进行了改变，其他的线程可以立即看到修改的值

2、Java中的可见性

Java提供了volatile关键字来保证可见性
当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

3、有序性

1、定义

即程序执行的顺序按照代码的先后顺序执行。

例子：
int i = 0;              
boolean flag = false;
i = 1;                //语句1  
flag = true;          //语句2

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值
操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语
句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，
因为处理器在进行重排序时是会考虑指令之间的数据依赖性

指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。所以想要要想并
发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，
就有可能会导致程序运行不正确。

2、Java中的有序性

在Java里面，可以通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

三、深入理解volatile关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。

1. volatile保证可见性的过程

//线程1
boolean stop = false;
while(!stop){
    doSomething();
}

//线程2
stop = true;

1、在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），volatile关键字会强制将修改的值立即写入主存
2、volatile会使得线程1的工作内存中缓存变量stop的缓存行无效，当线程1读取变量stop时，它会等待缓存行对应的主存地址被更新之后在读取，这时就可以去对应的主存读取到最新的值。

2. volatile不能保证原子性

例子：
public class Test {
    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

运行它会发现每次运行结果都不一致，都是一个小于10000的数字。
volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。
自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

假如某个时刻变量inc的值为10，
线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；
线程2从主存中读取到inc的最新值10，然后对inc进行加一操作，得到11，并把11写入工作内存，最后写入主存。  
此时线程1解除阻塞状态，inc的值仍为10，进行加一操作写入内存中，最后内存中的inc的值为11，二不是12

解决方案：可以通过synchronized或lock，进行加锁，来保证操作的原子性。也可以通过AtomicInteger。

3. volatile保证有序性

volatile关键字禁止指令重排序有两层意思：

1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
2）在进行指令优化时，不能将在对volatile变量的读操作或者写操作的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

4. volatile的底层实现原理

1、可见性

如果对声明了volatile变量进行写操作时，JVM会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写会到系统内存。 这一步确保了如果有其他线程对声明了volatile变量进行修改，则立即更新主内存中数据。
但这时候其他处理器的缓存还是旧的，所以在多处理器环境下，为了保证各个处理器缓存一致，每个处理会通过嗅探在总线上传播的数据来检查 自己的缓存是否过期，当处理器发现自己缓存行对应的内存地址被修改了，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作时，会强制重新从系统内存把数据读到处理器缓存里。 这一步确保了其他线程获得的声明了volatile变量都是从主内存中获取最新的。

2、有序性

Lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。

5. volatile的应用场景

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

1）对变量的写操作不依赖于当前值
2）该变量没有包含在具有其他变量的不变式中

列举几个Java中使用volatile的几个场景。

1 状态标记量，例如根据状态标记，终止线程。
2 用于单例模式中的double check

参考文章：
你真的了解volatile关键字吗？