原文链接 了解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