volatile的定义
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的内存原理
先查看上一章节了解Java内存模型和并发编程的基本概念
这里稍微补充一点关于JAVA内存模型的概念。
什么是内存模型呢？就是程序运行起来时，内存里面的样子。程序包括变量，对象，数据，指令等，程序动起来后又包括变量如何赋值，数据如何读取，指令按什么顺序执行等。其实，程序运行时，内存是什么样子，通常取决于操作系统，也就是说是由操作系统决定的。Java是跨平台的语言，其靠着“Compile once, run anywhere”的大旗，拮杆而起，打下一片天下，如今稳坐头把交椅。那么，想要跨平台，它就要屏蔽各个操作系统平台和硬件平台的差异，因此它有虚拟机，虚拟机实质是一对操作系统的一个抽象，把差异进行屏蔽，从而对语言本身来说，所有操作系统就都是一样的了。内存模型，也就是虚拟机对运行时的一些约定，或者叫做强制规定，比如变量的操作，数据的读取，指令执行顺序等。
- 线程模型
因为Java天生支持多线程，所以，虚拟机也必须要有线程模型，否则就无法屏蔽操作系统的差异。虚拟机规定，所有的变量都存储在主存中，也就是通常所指的内存，每个线程可以有自己的独立的工作内存，可以理解为每个CPU核心的缓存，线程对变量的操作都只能在自己的工作内存中，不能直接对主存操作，也不能访问其他线程的工作内存。
- 指令重排与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规则产生实际作用。