volatile是“轻量级”synchronized，保证了共享变量的“可见性”（JMM确保所有线程看到这个变量的值是一致的），使用和执行成本比synchronized低，因为它不会引起线程上下文切换和调度。

缓存一致性问题：

一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

解决方法（都是在硬件上实现的）：

• 通过在总线加LOCK#锁的方式

  在总线上加锁，会导致其他CPU无法访问主存，效率降低

• 缓存一致性协议

  最出名的是Intel的MESI协议，该协议保证了每个缓存中使用的共享变量的副本是一致的。其思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

共享变量写回主存流程

处理器在执行内存写操作的时候，往往是先将数据写入其写缓冲器中，而不是直接写入高速缓存。一个处理器上的写缓冲器中的内容无法被其他处理器所读取，因此写线程必须确保其对volatile变量所做的更新以及其更新volatile变量前对其他共享变量所做的更新到达该处理器的高速缓存（而不是仍然停留在写缓冲器中）。这样，写线程的这些更新通过缓存一致性协议被其他处理器上的线程所读取才成为可能。为此，Java虚拟机（JIT编译器）会在volatile变量写操作之后插入一个StoreLoad内存屏障。这个内存屏障的其中一个作用就是将其执行处理器的写缓冲器中的当前内容写入高速缓存，并将高速缓存的内容写回主存。

同时，由于无效化队列（暂存无效化消息的硬件，使得修改了某个共享变量之后借以通知其他处理器其对共享变量的更新，以便其他处理器能够将其高速缓存中的相应缓存行置为无效）的存在，处理器从其高速缓存中读取到的共享变量值可能是过时的。因此，为了确保读线程能够读取到写线程对共享变量所做的更新（包括volatile变量），读线程的执行处理器必须在读取volatile变量前确保无效化队列中内容被应用到该处理器的高速缓存中，即根据无效化队列中的内容将该处理器中相应的缓存行设置为无效，从而使写线程对共享变量所做的更新能够被反映到该处理器的高速缓存上。

若对声明了volatile的变量进行写操作，JVM会向处理器发送一条Lock前缀的指令，将这个变量所在缓存航的数据写会主存。但是，就算回到主存，还要保证其他处理器的缓存是一致的。每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是否过期了，当处理器发现自己缓存行对应的内存地址被修改时，就会设置当前缓存行为无效，需要对数据进行修改的时候会重新从主存中加载。

被volatile修饰的含义

1. 保证变量的可见性
2. 禁止指令重排序

为何volatile不保证原子性

原子性即要么做要么不做，举个例子

x = 10;     //语句1
y = x;      //语句2
x++;        //语句3
x = x + 1;  //语句4

只有语句1是原子性操作，其他三个都不是，因为是复合操作，讲讲最典型的自增操作，自增分为三步骤：读取变量的原始值、+1操作、写入主存，也就是说，这三个子操作可能会割开执行：

假如volatile修饰的变量x原本为10，现线程A和B同时进行x++

线程A对变量进行自增，取出变量，阻塞

线程B对变量进行自增，取出变量，由于线程A仅仅取出变量，没有对变量进行操作，因此不会造成线程B中缓存变量x的缓存行无效，进行x++后x变为11，写入内存

线程A因为已经读取出来，已经过了取变量这一步，此时会直接进行x++，x为11，写入内存

也就是说，简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的互相赋值不是原子操作）才是原子操作，JMM仅保证了基本读取和赋值是原子操作，如果要实现更大范围的原子性操作，可以通过锁机制

针对以上的x++可能会有一些歧义，因为线程B修改过变量x，返回线程A的时候缓存无效，应该修改，这是没错的，但需要注意这里是缓存，然而x++的时候会先将x赋值给另外一个临时变量（设为tmp），tmp属于工作内存的局部变量表，再将tmp返回到缓存，缓存再返回到主存，这里需要一些寄存器运算的知识。形象一些，可以把x++拆分成以下

int tmp = x;    //1
tmp = tmp + 1;  //2
x = tmp;        //3

当线程B调回线程A的时候，x会发生改变，但是tmp不变，因为已经执行完了第一步。

保证原子性可以通过锁（synchronized或者Lock）或者AtomicInteger的getAndIncrement()

AtomicInteger其实是利用CAS（Compare And Swap）实现原子操作，CAS是利用处理器提供的CMPXCHG指令实现的，处理器执行这个指令是一个原子操作

volatile在一定程度上保证有序性

volatile关键字禁止指令重排序有两层意思（不完全禁止）：

• 当程序执行到volatile变量的读或写时，在其前面的操作肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
• 在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

举个例子

//x、y为非volatile变量
//flag为volatile变量
 
x = 2;         //语句1
y = 0;         //语句2
flag = true;   //语句3
x = 4;         //语句4
y = -1;        //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

volatile实现的两条原则（保证可见性和禁止指令重排序）

• Lock前缀指令会引起处理器缓存回写到内存。

  lock前缀指令相当于一个内存屏障（也称内存栅栏），内存屏障主要提供3个功能：

  1. 确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
  2. 强制将对缓存的修改操作立即写入主存，利用缓存一致性机制，并且缓存一致性机制会阻止同时修改由两个以上CPU缓存的内存区域数据；
  3. 如果是写操作，它会导致其他CPU中对应的缓存行无效。

• 一个处理器的缓存回写到内存会导致其他处理器的缓存失效。

  处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存的数据在总线上保持一致。例如CPU A嗅探到CPU B打算写内存地址，且这个地址处于共享状态，那么正在嗅探的处理器将使它的缓存行无效，在下次访问相同内存地址时，强制执行缓存行填充。

volatile写和volatile读的内存语义

• 线程A写一个volatile变量,实质上是线程A向接下来将要读这个volatile变量的某个线程发出了(其对共享变量所做修改的)消息。
• 线程B读一个volatile变量,实质上是线程B接收了之前某个线程发出的(在写这个volatile变量之前对共享变量所做修改的)消息。
• 线程A写一个volatile变量,随后线程B读这个volatile变量,这个过程实质上是线程A通过主内存向线程B发送消息。

使用volatile的场景

必须具备以下两个条件（其实就是先保证原子性）：

• 对变量的写不依赖当前值（比如++操作）
• 该变量没有包含在具有其他变量的不等式中

比如：

• 状态标记（while(flag){})
• double check（单例模式）

参考：

《java并发编程的艺术》
http://www.cnblogs.com/dolphin0520/p/3920373.html#!comments