浅谈 volatile 实现原理

synchronized 是一个重量级的锁，的 volatile 则是轻量级的 synchronized ，它在多线程开发中保证了共享变量的“可见性”。若是一个变量使用 volatile ，则它比使用 synchronized 的成本更加低，由于它不会引发线程上下文的切换和调度。

Java 编程语言容许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保经过排他锁单独得到这个变量。 通俗点讲就是说一个变量若是用 volatile 修饰了，则 Java 能够确保全部线程看到这个变量的值是一致的。若是某个线程对 volatile 修饰的共享变量进行更新，那么其余线程能够立马看到这个更新，这就是所谓的线程可见性。

内存模型相关概念

理解 volatile 其实仍是有点儿难度的，它与 Java 的内存模型有关，因此在理解 volatile 以前咱们须要先了解有关 Java 内存模型的概念。

操做系统语义

计算机在运行程序时，每条指令都是在CPU中执行的，在执行过程当中势必会涉及到数据的读写。咱们知道程序运行的数据是存储在主存中，这时就会有一个问题，读写主存中的数据没有 CPU 中执行指令的速度快，若是任何的交互都须要与主存打交道则会大大影响效率，因此就有了 CPU 高速缓存。CPU高速缓存为某个CPU独有，只与在该CPU运行的线程有关。

有了 CPU 高速缓存虽然解决了效率问题，可是它会带来一个新的问题：数据一致性。

在程序运行中，会将运行所须要的数据复制一份到 CPU 高速缓存中，在进行运算时 CPU 再也不也主存打交道，而是直接从高速缓存中读写数据，只有当运行结束后，才会将数据刷新到主存中。

举一个简单的例子：

i = i + 1;
复制代码

当线程运行这段代码时，首先会从主存中读取 i 的值( 假设此时 i = 1 )，而后复制一份到 CPU 高速缓存中，而后 CPU 执行 + 1 的操做（此时 i = 2），而后将数据 i = 2 写入到告诉缓存中，最后刷新到主存中。

其实这样作在单线程中是没有问题的，有问题的是在多线程中。以下：

假若有两个线程 A、B 都执行这个操做（ i++ ），
复制代码

按照咱们正常的逻辑思惟主存中的i值应该=3 。

但事实是这样么？分析以下：

两个线程从主存中读取 i 的值( 假设此时 i = 1 )，到各自的高速缓存中，
而后线程 A 执行 +1 操做并将结果写入高速缓存中，最后写入主存中，此时主存 i = 2 。
线程B作一样的操做，主存中的 i 仍然 =2 。因此最终结果为 2 并非 3 。
这种现象就是缓存一致性问题。
复制代码

解决缓存一致性方案有两种：

经过在总线加 LOCK# 锁的方式
经过缓存一致性协议
复制代码

第一种方案存在一个问题，它是采用一种独占的方式来实现的，即总线加 LOCK# 锁的话，只能有一个 CPU 可以运行，其余 CPU 都得阻塞，效率较为低下。

第二种方案，缓存一致性协议（MESI 协议），它确保每一个缓存中使用的共享变量的副本是一致的。其核心思想以下：当某个 CPU 在写数据时，若是发现操做的变量是共享变量，则会通知其余 CPU 告知该变量的缓存行是无效的，所以其余 CPU 在读取该变量时，发现其无效会从新从主存中加载数据。

Java内存模型

上面从操做系统层次阐述了如何保证数据一致性，下面咱们来看一下 Java 内存模型，稍微研究一下它为咱们提供了哪些保证，以及在 Java 中提供了哪些方法和机制，来让咱们在进行多线程编程时可以保证程序执行的正确性。

在并发编程中咱们通常都会遇到这三个基本概念：原子性、可见性、有序性。咱们看下volatile 。

原子性

原子性：即一个操做或者多个操做，要么所有执行而且执行的过程不会被任何因素打断，要么就都不执行。

原子性就像数据库里面的事务同样,咱们看下面一个简单的例子便可：

i = 0;  // <1>
j = i ;  // <2>
i++;  // <3>
i = j + 1; // <4>
复制代码

上面四个操做，有哪一个几个是原子操做，那几个不是？若是不是很理解，可能会认为都是原子性操做，其实只有 1 才是原子操做，其他均不是。

1. 在 Java 中，对基本数据类型的变量和赋值操做都是原子性操做。
2. 包含了两个操做：读取 i，将 i 值赋值给 j 。
3. 包含了三个操做：读取 i 值、i + 1 、将 +1 结果赋值给 i 。
4. 同 <3> 同样

那么 64 位的 JDK 环境下，对 64 位数据的读写是不是原子的呢？

实现对普通long与double的读写不要求是原子的（但若是实现为原子操做也OK）
实现对volatile long与volatile double的读写必须是原子的（没有选择余地）
复制代码

另外，volatile 是没法保证复合操做的原子性

可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其余线程可以当即看获得修改的值。

在上面已经分析了，在多线程环境下，一个线程对共享变量的操做对其余线程是不可见的。

Java提供了 volatile 来保证可见性。

当一个变量被 volatile 修饰后，表示着线程本地内存无效。

当一个线程修改共享变量后他会当即被更新到主内存中；

当其余线程读取共享变量时，它会直接从主内存中读取。

synchronize 和锁均可以保证可见性。

有序性

有序性：即程序执行的顺序按照代码的前后顺序执行。

在 Java 内存模型中，为了效率是容许编译器和处理器对指令进行重排序，固然重排序它不会影响单线程的运行结果，可是对多线程会有影响。

Java 提供 volatile 来保证必定的有序性。最著名的例子就是单例模式里面的 DCL（双重检查锁）。

剖析 volatile 原理

volatile 能够保证线程可见性且提供了必定的有序性，可是没法保证原子性。在 JVM 底层，volatile 是采用“内存屏障”来实现的。

上面那段话，有两层语义：

保证可见性、不保证原子性
禁止指令重排序
复制代码

第一层语义就不作介绍了，下面重点介绍指令重排序。

指令重排序

在执行程序时为了提升性能，编译器和处理器一般会对指令作重排序：

编译器重排序。编译器在不改变单线程程序语义的前提下，能够从新安排语句的执行顺序。
处理器重排序。若是不存在数据依赖性，处理器能够改变语句对应机器指令的执行顺序。
复制代码

指令重排序对单线程没有什么影响，他不会影响程序的运行结果，可是会影响多线程的正确性。既然指令重排序会影响到多线程执行的正确性，那么咱们就须要禁止重排序。那么JVM是如何禁止重排序的呢？

由此引出happen-before原则

1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操做，happens-before 于书写在后面的操做。
2. 锁定规则：一个 unLock 操做，happens-before 于后面对同一个锁的 lock 操做。
3. volatile 变量规则：对一个volatile变量的写操做，happens-before 于后面对这个变量的读操做。注意是后面的.
4. 传递规则：若是操做 A happens-before 操做 B，而操做 B happens-before 操做C，则能够得出，操做 A happens-before 操做C
5. 线程启动规则：Thread 对象的 start 方法，happens-before 此线程的每一个一个动做。
6. 线程中断规则：对线程 interrupt 方法的调用，happens-before 被中断线程的代码检测到中断事件的发生。
7. 线程终结规则：线程中全部的操做，都 happens-before 线程的终止检测，咱们能够经过Thread.join() 方法结束、Thread.isAlive() 的返回值手段，检测到线程已经终止执行。
8. 对象终结规则：一个对象的初始化完成，happens-before 它的 finalize() 方法的开始

咱们着重看第三点 Volatile规则：对 volatile变量的写操做，happen-before 后续的读操做。

为了实现 volatile 内存语义，JMM会重排序，其规则以下：

当第二个操做是 volatile 写操做时，无论第一个操做是什么，都不能重排序。
这个规则，确保 volatile 写操做以前的操做，都不会被编译器重排序到 volatile 写操做以后。
复制代码

对 happen-before 原则有了稍微的了解，咱们再来回答这个问题 JVM 是如何禁止重排序的？

观察加入 volatile 关键字和没有加入 volatile 关键字时所生成的汇编代码发现，
加入volatile 关键字时，会多出一个 lock 前缀指令。
lock 前缀指令，其实就至关于一个内存屏障。
内存屏障是一组处理指令，用来实现对内存操做的顺序限制。
volatile 的底层就是经过内存屏障来实现的。
复制代码

下图是完成上述规则所须要的内存屏障：

总结

volatile 看起来简单，可是要想理解它仍是比较难的，这里只是对其进行基本的了解。

volatile 相对于 synchronized 稍微轻量些，在某些场合它能够替代 synchronized ，可是又不能彻底取代 synchronized 。只有在某些场合才可以使用 volatile，使用它必须知足以下两个条件：

对变量的写操做，不依赖当前值。
该变量没有包含在具备其余变量的不变式中。
复制代码

volatile 常常用于如下场景：状态标记变量、Double Check .一个线程写多个线程读。