共计 6905 个字符，预计需要花费 18 分钟才能阅读完成。
原文链接 了解 Java 关键字 volatile
在 Java 中，关键字 volatile 是除同步锁以外，另一个同步机制，它应用起来比锁要简略不便，然而却很容易被疏忽，或者被误用。这篇文章就来具体解说一下 volatile 它的作用，它的原理以及如何正确的应用它。
volatile 的定义
这个援用 JSR 中的定义：
The Java programming language allows threads to access shared variables (§17.1). As a rule, to ensure that shared variables are consistently and reliably updated, a thread should ensure that it has exclusive use of such variables by obtaining a lock that, conventionally, enforces mutual exclusion for those shared variables.
The Java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes.
A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable (§17.4).
简略的翻译一下：
Java 编程语言中容许线程访问共享变量。为了确保共享变量能被统一地和牢靠的更新，线程必须确保它是排他性的应用此共享变量，通常都是取得对这些共享变量强制排他性的同步锁。
Java 编程语言提供了另一种机制，volatile 域变量，对于某些场景的应用这要更加的不便。
能够把变量申明为 volatile，以让 Java 内存模型来保障所有线程都能看到这个变量的同一个值。
volatile 的作用
-
保障变量的可见性
volatile 关键字的作用就是保障共享变量的 可见性。什么是可见性呢，就是一个线程读变量，总是能读到它在内存中的最新的值，也就是说不同的线程看到的一个变量的值是雷同的。CPU 都是有行缓存的，volatile 能让行缓存有效，因而能读到内存中最新的值。
-
保障赋值操作的原子性
原子性就是不能被线程调度打断的操作，是线程平安的操作，对于原子性操作，即便在多线程环境下，也不必放心线程平安问题或者数据不统一的问题。有些变量的赋值自身就是原子性的，比方对 boolean，对 int 的赋值，然而像对于 long 或者 double 则不肯定，如果是 32 位的处理器，对于 64 位的变量的操作可能会被合成成为二个步骤：高 32 位和低 32 位，由此可能会产生线程切换，从而导致线程不平安。如果变量申明为 volatile，那么虚构机会保障赋值是原子的，是不可被打断的。
-
禁止指令重排
失常状况下，虚构机会对指令进行重排，当然是在不影响程序后果的正确性的前提下。volatile 可能在肯定水平上禁止虚拟机进行指令重排。还有就是对于 volatile 变量的写操作，保障是在读操作之前实现，假如线程 A 来读变量，刚好线程 B 正在写变量，那么虚构机会保障写在读之前实现。
比方：
private volatile boolean flag;
public void setFlag(boolean flag) {this.flag = flag;}
public void getFlag() {return flag;}假如线程 A 来调用 setFlag(true)，线程 B 同时来调用 getFlag，对于个别的变量，是无奈保障 B 能读到 A 设置的值的，因为它们执行的程序是未知的。然而像下面，加上 volatile 润饰当前，虚构机会保障，线程 A 的写操作在线程 B 的读操作之前实现，换句话，B 能读到最新的值。当然了，用锁机制也能达到同样的成果，比方在办法后面都加上 synchronized 关键字，然而性能会远不如应用 volatile。
volatile 的典型应用场景
多线程状况下的标记位
基于它的作用，不难找到应用它的现实场景：
- 读操作，多于写操作
- 写操作，不依赖于变量的以后值，也就是说要是纯赋值操作
- 只须要读取的值，不须要期待某一特定的值
比方，有一个查看新版本的按扭，点击时会发动去查看新版本，因为查看新版本波及网络申请，可能会比拟耗时，所以须要放在独自的线程中去做。为了防止屡次同时触发查看申请，做一个限度：上一个申请没有实现时，再次点击有效。这时就能够用 volatile 来做个标记位，伪代码如下：
private volatile boolean checkUpdateFinished = true;
public void onCheckUpdate(View view) {if (!checkUpdateFinished) {return;}
checkUpdate();}
private void checkUpdate() {
checkUpdateFinished = false;
new Thread(new Runnable() {
@Override
public void run() {doCheckUpdate();
checkUpdateFinished = true;
}
}).start();}CAS 无锁同步的变量申明
CAS（Compare And Swap）是一种无锁同步的算法，它波及变量的 3 个值，以后值，旧的期望值以及新的期望值，它的原理是当且仅当以后值与旧的期望值统一时，才把新值赋给变量，否则什么都不做：
private volatile int a;
do {
old = 3;
expected = 5;
} while (compareAndSwap(a, 3, 5);
boolean compareAndSwap(int a, int old, int expected) {if (a == old) {
a = expected;
return true;
}
return false;
}当然，具体的 compare and swap 不是这么实现的，理论是要间接应用解决的指令 CMPXCHG(Compare and Exchange)来做具体的 CAS。
为了保障可见性，CAS 中的变量必须都用 volatile 来润饰。
volatile 的内存原理
晓得了 volatile 有什么用，怎么用当前，能够理解的更深一点，以加深了解。但要搞懂，就必须先要搞懂它的背景以及背景的背景：
并发的基本概念
-
原子性
一个或者多个操作（赋值也好，运算也好）不能被线程调度打断，要么一次性执行完，要么就不执行。
-
可见性
古代处理器是多外围的，或者多 CPU 的，然而主存（通常意义上的操作系统内存，或者物理内存）却是在 CPU 之间共享的。多外围解决的劣势在于，从机器级别反对多线程并发，而且为了补救主存与 CPU 外围之间的速度差别，便有了 CPU 外围缓存，因而，每个 CPU 外围（或者说每个线程）是有独立的内存的。这样就带来了可见性的问题，同一个变量 c，A 线程操作的是 c 在 A 线程的缓存中的值，B 操作的是 c 在 B 的缓存中值，也就是说最新的变量的值对于其余线程是不可见的，这就有了可见性的问题。
-
有序性
对于单线程来说，程序的执行程序就是依照代码的书写程序，从上到下，从左到右 (分号分隔写在同一行时)。然而多线程状况就不肯定了，线程调度器随时可能打断某一程，执行其余线程。这就导致了，程序并不是依照预期的程序执行的，导致后果跟预期不统一。
留神：这里的程序，并不是严格的指令执行的程序，而且从后果正确性的角度来看的，比方：
int a = 10;
int b = a + 1;这段代码的有序性的意思是：当执行到第二条语句，只有 a 的值是 10 就能够了，至于 a = 10 它到底是否是在上面语句前执行，并不关怀。然而，除了 a = 10 语句外，没有其余的形式能让 a 变成 10，所以，必定是执行了语句了能力把 a 变成 10。说起来比拟绕，这个例子也过于简略。然而能够这么简略的了解为：单线程状况下，程序是按书写的程序来执行的，更精确的说法是程序员预期的程序来执行的。但多线程会突破这种有序性。
留神：这里咱们不思考 ABA 问题。
对内存模型的了解
什么是内存模型呢？就是程序运行起来时，内存外面的样子。程序包含变量，对象，数据，指令等，程序动起来后又包含变量如何赋值，数据如何读取，指令按什么程序执行等。其实，程序运行时，内存是什么样子，通常取决于操作系统，也就是说是由操作系统决定的。Java 是跨平台的语言，其靠着“Compile once, run anywhere” 的大旗，拮杆而起，打下一片天下，现在稳坐头把交椅。那么，想要跨平台，它就要屏蔽各个操作系统平台和硬件平台的差别，因而它有虚拟机，虚拟机本质是一对操作系统的一个形象，把差别进行屏蔽，从而对语言自身来说，所有操作系统就都是一样的了。内存模型，也就是虚拟机对运行时的一些约定，或者叫做强制规定，比方变量的操作，数据的读取，指令执行程序等。都做了哪些规定呢？咱们别离来说：
- 线程模型
因为 Java 天生反对多线程，所以，虚拟机也必须要有线程模型，否则就无奈屏蔽操作系统的差别。虚拟机规定，所有的变量都存储在主存中，也就是通常所指的内存，每个线程能够有本人的独立的工作内存，能够了解为每个 CPU 外围的缓存，线程对变量的操作都只能在本人的工作内存中，不能间接对主存操作，也不能拜访其余线程的工作内存。-
原子性操作
虚拟机保障对根本的根本数据类型的赋值是原子的，比方 int，boolean 和 float。然而像 long 和 double 不肯定，这取决于 CPU 的字长，32 位下，long 和 double 的赋值不是原子的，因为须要二个指令；而 64 位 CPU 则一个指令搞定。
如何保障原子性呢？形式一是下面提过的用 volatile，另外就是用同步锁机制。
-
可见性
后面说到每个 CPU 能够有本人的工作内存，因而，当一个线程对某一变量操作后，其余线程是没有方法间接拿到最新变动的。
如何保障可见性呢？办法一就是把变量用 volatile 润饰，另外就是用同步锁机制。
-
指令重排与 happens-before 准则
指令重排与 happens-before 起因，是不同的，也是不抵触的。失常状况下，也就是说单线程状况下，指令的执行程序是按书写程序从上到下，但不是严格的，虚构机会在不影响程序后果正确性的前提下对指令进行重排，比方：
int a = 1;
int b = 2;
int c = 3;这三个指令，哪个先执行，是不会影响程序后果的，这时指令可能重排；而再如：
int a = 1;
int b = a + 1;
int c = a + b;这种状况下，是无奈重排，不可能把第 3 句放到后面，那样会得不到正确的后果。
而 happens-before 是指在多线程状况下，虚拟机来保障某些操作的先后性，或者说后面的操作后果，对前面是可见的。比方下面的第二个例子，在多线程状况下，c = a + b 是有可能在 a, b 赋值前执行的，这也恰 恰是咱们须要小心解决的由多线程机制带来的问题。
虚拟机的默认反对的 happens-before(后行产生)准则：
- 程序秩序规定：一个线程内，依照代码程序，书写在后面的操作后行产生于书写在前面的操作
- 锁定规定：一个 unLock 操作后行产生于前面对同一个锁额 lock 操作
- volatile 变量规定：对一个变量的写操作后行产生于前面对这个变量的读操作
- 传递规定：如果操作 A 后行产生于操作 B，而操作 B 又后行产生于操作 C，则能够得出操作 A 后行产生于操作 C
- 线程启动规定：Thread 对象的 start()办法后行产生于此线程的每个一个动作
- 线程中断规定：对线程 interrupt()办法的调用后行产生于被中断线程的代码检测到中断事件的产生
- 线程终结规定：线程中所有的操作都后行产生于线程的终止检测，咱们能够通过 Thread.join()办法完结、Thread.isAlive()的返回值伎俩检测到线程曾经终止执行
- 对象终结规定：一个对象的初始化实现后行产生于他的 finalize()办法的开始
很多规定不言而喻的，或者想一下还是很容易想通的，重点解析一下第 2, 3, 4 条：
-
锁定规定：一个 unLock 操作后行产生于前面对同一个锁额 lock 操作
这里的意思是，同一个锁(lock)，如果处于锁定状态，那么只能先开释锁，而后能力被再次锁定。这么一说就明确了，这是不言而喻的，要不然锁不就失去它自身的作用了么。
留神：这里有必要进一步阐明一下，对于可重入锁，这里应该指的就是其余线程再次取得锁之前，锁必须被开释。因为对于可重入锁，锁的持有线程，是能够在不开释的前提下，持续取得锁的。
-
volatile 变量规定：对一个变量的写操作后行产生于前面对这个变量的读操作
这里其实有二层，一个是后面提过的，读 volatile 总是能读到最新的值，即便是写线程和读线程同时进行。因为，写操作会被更新到主存，读线程的工作内存会被置为有效，须要从新到主存去读，而读主存的地址，是要期待该地址更新后能力胜利读取。
另外，一个就是对于 volatile 上下文的变量的读写的影响，也就是说它为什么能禁止指令重排：volatile 的精确可见性作用是，当一个线程写一个 volatile 变量时，写实现后会刷新工作内存到主存，这会把目前这个线程所做过批改的所有变量都刷新到主存。举个例子来阐明：
int a;
int b;
volatile boolean flag;
void write() {
a = 3;
b = 4;
flag = true;
}
void read() {print(a);
print(b);
print(flag);
}如果线程 A 调用 write()，线程 B 调用 read()，那么 B 能读到 a, b 和 flag 的最新值（A 所写的值）。
由此，能够引申出一个 volatile 的高级利用，能够当作同步锁：
private Object object = null;
private volatile hasNewObject = false;
public void put(Object newObject) {while (hasNewObject) {//wait - do not overwrite existing new object}
object = newObject;
hasNewObject = true; //volatile write
}
public Object take() {while (!hasNewObject) { //volatile read
//wait - don't take old object (or null)
}
Object obj = object;
hasNewObject = false; //volatile write
return obj;
}因为写 hasNewObject 时会把 object 也刷新了，所以取对象的线程，能够在只有 hasNewObject 为 true 时就能够读到正确的值。
- 传递规定：如果操作 A 后行产生于操作 B，而操作 B 又后行产生于操作 C，则能够得出操作 A 后行产生
这个就像某些运行符的传递性一样，具体传递性，从而使整个 happens-before 规定产生理论作用。
volatile 的实现机制
计算机科学外面，为了解决复杂性，都会分层。正如一个名人所说：” 计算机的任何问题都能够通过减少一个虚构层来解决 ”(“All problems in computer science can be solved by another level of indirection”)。volatile 虚拟机层引入的，解决语言层面的问题，那么它的实现，必然是靠下一层的反对，也就是须要汇编或者说处理器指令的反对来实现，volatile 是靠内存屏障和 MESI（缓存一致性协定）来达成的它的作用的。
内存屏障 (Memory Barriers) 是处理器提供的一组内存操作指令，它的作用是限度内存操作的程序，也就是说内存屏障像一个栅栏一样，它后面的指令要在它前面的指令之前实现；还能强制把缓存写入到主存；再有的就是触发缓存一致性，就是当有写变量时，会把其余 CPU 外围的缓存变为有效。
总结
volatile 是一个比较复杂的修饰符，想要应用它，就要齐全了解它的作用，它能用来做什么，以及不能干什么。如果，不是很确定，要么弄懂，要么就不要应用。事实上，大多数状况下，标记变量，还是非常适合 volatile 的。
java.util.concurrent.* 外面的高级线程平安数据结构像 ConcurrentHashMap 以及 java.util.concurrent.atomic.* 等的实现都用到了 volatile。能够多看看这些类的实现，以加深对 volatile 的了解和使用。
参考资料
- Java 实践与实际: 正确应用 Volatile 变量
- Java 并发编程：volatile 关键字解析
- 深刻了解 Java 内存模型（四）——volatile
- 聊聊并发（一）——深入分析 Volatile 的实现原理
- Java Volatile Keyword
- volatile (computer programming))
- Java Memory Model