1. 概述
关键字volatile可以说时Java虚拟机提供的最轻量级的同步机制，但是它并不容易完全被正确、完整的理解，以至于许多程序员都不习惯去使用它，遇到需要处理并发问题的时候，一律使用synchronized(synchronized通常称为重量级锁)来进行同步。
2. 基本概念
Java内存模型是围绕着在并发过程中如何处理 原子性、可见性 和 有序性 这3个特征来建立的，我们先来看一下这三个特性。
1. 原子性：
由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store和write，我们大致可以认为基本数据类型的访问读写是具备原子性的（例外的是long和double的非原子性协定，读者只要知道这件事情就可以了）
如果应用场景需要一个更大范围的原子性保证（比如实现一个单例模式的连接等，在实际应用中很常见），Java内存模型还提供了lock和unlock操作来满足这种需求，尽管虚拟机未把lock和unlock操作直接开放给用户使用，但是却提供了更高层次的字节码指令monitorenter和monitorexit来隐式的使用这两个操作，这两个字节码指令反映到Java代码中就是由synchronized关键字标识的代码同步块，因此在synchronized块之间的操作也具备原子性。
辅助理解：
int a = 0；
如上是一个简单的赋值操作（注意：a是非long和double类型的基本类型数据，double和long类型比较特殊）， 这个操作是不可分割的，即，这个操作没办法再进行拆分，那么我们说这个操作是原子操作。
再比如下面这个操作：
a++；
这个操作实际是a = a + 1；是可分割的，所以这不是一个原子操作。
非原子操作都会存在线程安全问题，需要我们使用同步技术（如使用sychronized关键字）来让它变成一个原子操作。
一个操作是原子操作，那么我们称它具有原子性。
Java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。
2. 可见性：
可见性，是指线程之间的可见性，当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。也就是一个线程修改的结果，另一个线程马上就能看到。
Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的。
所以，无论是普通变量还是volatile修饰的变量都是如此，而二者之间的区别是：volatile的特殊规则保证了新值能 立即 同步到主内存，以及每次使用前 立即 从主内存刷新。而普通变量则不能保证这一点。
在 Java 中 volatile、synchronized 和 final 三个关键字可以实现可见性。
可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。
比如，用volatile修饰的变量会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即，直接修改内存，所以对其他线程是可见的。
但是这里需要注意一个问题：volatile只能让被它修饰的变量具有可见性，但不能保证它具有原子性。
如下操作：
volatile int a = 0；
……其他操作
a++；
……其他操作
这个变量a具有可见性，但是a++依然是一个非原子操作，也就是这个操作同样存在线程安全问题。
3. 有序性：
Java程序中天然的有序性可以总结为一句话：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。
前半句是指线程内表现为串行的语义，后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象
Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。
3. volatile原理
Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。
当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。
volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。
在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中。
而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步。
当一个变量定义为 volatile 之后，将具备两种特性：
- 保证此变量对所有的线程的可见性，这里的“可见性”是指：当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存来完成。
注意：
在讲原子性的时候讲到过，volatile修饰的变量并不能保证原子性操作，即，如果被volatile修饰的变量的运算并非原子操作，那么在并发的情况下，该运算同样是不安全的。也即，volatile修饰的变量只能保证可见性和有序性，不一定能保证原子性。
如下代码，就会出现并发问题：
package JavaCore;
public class VolatileTest {
public static volatile int race = 0;
public static void increase() {
// 可拆解为race = race + 1;，而race + 1也不是原子性的操作
race++;
}
private static final int THREADS_COUNT = 20;
public static void main(String[] args) {
Thread[] threads = new Thread[THREADS_COUNT];
for (int i = 0; i < THREADS_COUNT; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
increase();
}
}
});
threads[i].start();
}
// 等待1分钟，足够运算完成了
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(race);
}
}
我们期待的结果是20000，但最终的结果往往比这个结果要小。
所以，在不满足如下两条规则的运算场景中，我们仍然要通过加锁（使用synchronized关键字或使用java.util.concurrent中的原子类）来保证原子性。规则如下：
a. 运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。
b. 变量不需要与其他的状态变量共同参与不变约束。
结合上面的代码看，我们可以看出在increase()方法中，race的结果是依赖当前race值的。
下面代码展示的就是很适合使用volatile变量来控制并发，当shutdown()方法被调用时，能保证所有线程中执行的doWork()方法立即停下来。
volatile boolean shutdownRequested;
public void shutdown() {
shutdownRequested = true;
}
public void doWork() {
while(!shutdownRequested) {
// do stuff
}
}
- 禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个CPU访问内存时，并不需要内存屏障；
什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理。
volatile 性能：
volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。