有时候仅仅为了一个或者两个的实例域就是用synchronized的话，开销就会很大，而Java为我们提供了另一种同步的免锁机制，volatile。Volatile可以看成是synchronized的轻量级，功能也仅仅是synchronized的一部分，认识volatile之前，先认识Java内存模型和Java的原子性，可见性，有序性
Java的内存模型
在Java虚拟机中，每一个线程私有的就是JVMstack ，本地方法栈，PC，而共享的就是Java堆和方法区（包含常量池）。Java创建的对象都在堆中分配，所有的实例域，静态变量，数组的元素都在堆中，都是被线程共享的。
而Java线程之间的通信是通过共享内存来实现的，也就是隐式通信，而线程通信是由Java内存模型控制的（JMM），JMM决定着一个线程对一个共享变量的写入修改何时对另一个线程可见（也就是另一个线程得到那个最新的修改值），JMM定义了线程与主存之间的抽象关系:线程之间的共享变量存储在主存中，每个线程在自己的栈中(栈中有栈帧)都有一个私有的本地内存空间，其他线程不可访问，本地内存保存着这个共享变量的拷贝。线程不能直接对共享变量直接写，先写入本地内存，然后由JMM决定什么时候将本地的值回写打主存中。
本地内存是JMM的一个抽象概念，并不真实存在，抽象示意图：
先看个例子：
public class
Main {
public staticvoid main(String[] args) {
Test test = new Test(5);
MyThread myThread =new
MyThread(test);
MyRunnablemyRunnable = new
MyRunnable(test);
Thread thread = new
Thread(myRunnable);
myThread.setName("MyThread");
thread.setName("MyRunnable");
thread.start();
myThread.start();
}
}
public class
Test {
public int test;
public Test(int
test) {
this.test
= test;
}
}
public class
MyThread extends
Thread {
Test test;
public MyThread(Test test) {
this.test
= test;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" "
+test.test);
test.test
= 10;
try {
System.out.println(Thread.currentThread().getName()+" test.test= 10;");
System.out.println(Thread.currentThread().getName()+"
睡觉");
Thread.currentThread().sleep(2000);
System.out.println(Thread.currentThread().getName()+" "
+test.test);
} catch
(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "
+test.test);
}
}
public class
MyRunnable implements
Runnable {
Test test;
public MyRunnable(Test test) {
this.test
= test;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" "
+test.test);
test.test
= 20;
// try {
System.out.println(Thread.currentThread().getName()+" test.test= 20;");
System.out.println(Thread.currentThread().getName()+""+test.test);
}
}
输出：（这个输出随机性很大，运行很多次才偶然得到）
MyRunnable 5
MyRunnable test.test = 20;
MyRunnable 20
MyThread 5
MyThread test.test = 10;
MyThread 睡觉
MyThread 10
MyThread 10
结果说明：在main线程创建了线程MyThread和MyRunnable两个线程，实例test的域原始值是5。由输出可以知道，MyRunnable线程先执行完之后MyThread线程才开始执行，可以看到，在MyRunnable线程中，我们把test对象的域改为了20，但是在MyThread线程中打印出来的值还是5，要么是MyRunnable的值没写回内存，要么就是MyThread的本地值是一开始test域没改之前的值(没更新MyRunnable改过的值)。这就很好的印证了上面那幅图
原子性
如果学过操作系统或者数据库都会有这样的概念，在生活中，A转100给B执行的语句就是
A = A -100；
B= B+100；
那么在数据库写入的时候就会用事务管理来操作，保证其原子操作，也就是害怕执行了 A = A -100；
突然故障导致不能往下执行，那么A就会无端端少了100，而B也没有得到这100，原子操作就是要么执行完全部，要么全部不执行，在数据库中，事务管理器针对上面的情况就会恢复A的值，也就是让A重新+100，恢复以前的值。Java的原子性也就是差不多的意思。
例子：
①X = 100;
②Y=X +100;
① 就是原子操作，对基本数据类型的写入和读取都是原子性操作，即这些操作要么不执行，要么执行，不能被打断
② 而就不是原子操作了，因为涉及到X的读取，X+100后赋值给Y，虽然这两个分开就是原子操作，但是结合一起就不是原子操作了，这两个过程可能被打断
原子就是不能再分的最小的例子，所以对应操作也是不能再分和打断
java.util.concurrent.atomic包含AtomicBoolean，AtomicLong和AtomicReference这些原子类仅供开发并发工具的系统程序员使用，应用程序员不应该使用这些类。
可见性
其实可见性在上面的代码例子中已经可以体现，意思就是线程1修改了共享变量的值之后，其他的线程可以知道这个变量值已经修改，并且能够得到这个新值
有序性
在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性,更多的了解可以看这里
重排序并不是Java特有的，在操作系统也是会有的，为了性能优化而重排序是很正常的
Volatile关键字
当一个变量定义为volatile之后，它具备两项特性
①可见性
②禁止指令重排序优化
可见性demo：
public class Main { public static void main(String[] args) throws InterruptedException { MyThread myThread = new MyThread(); myThread.start(); Thread.currentThread().sleep(1000); System.out.println("sleep 完成"); myThread.setFlag(true); }}
public class MyThread extends Thread { boolean flag = false; public void setFlag(boolean flag) { this.flag = flag; } @Override public void run() { while (!flag) { } } }
结果：
结果说明：
每个线程都有自己的工作（本地内存）内存，myThread线程读取了flag的值到自己的工作内存中，拷贝了一份，然后一直进入死循环，而当main线程也有自己的工作内存，它拿到了flag的值，改变了flag的值，但是或许还没来得及将它写会到住内存中就已经结束了，而myThread一直不知道flag的值已经改变，所以一直循环下去
加上volatile关键字
volatile boolean flag = false;
① 使用volatile修饰的变量，当变量改变之后，会立马强制写会内存
② 当某个线程修改了这个变量，其他线程使用前，会直接从内存中读取一次
Volatile不具有原子性（一般）
public class Main { volatile static int flag = 0; public static void increment() { flag++; } public static void main(String[] args) throws InterruptedException { final Main test = new Main(); for(int i=0;i<10;i++){ new Thread(){ public void run() { for(int j=0;j<1000;j++) test.increment(); }; }.start(); } //保证前面的线程都执行完 while(Thread.activeCount()>2) Thread.yield(); System.out.println(test.flag); } }
这里是jdk1.8所以while(Thread.activeCount()>2)如果还是1.7的话就改为大于1
输出的结果大多数情况下都是小于10000，因为自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行。
假如某个时刻变量inc的值为10，线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。然后线程1接着进行加1操作，由于已经读取了inc的值（不会再次去主存读数据），注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。那么两个线程分别进行了一次自增操作后，inc只增加了1。
自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。
正确使用 volatile 变量的条件
您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：
· 对变量的写操作不依赖于当前值。
· 该变量没有包含在具有其他变量的不变式中。
实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。
第一个条件的限制使 volatile
变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile
不能提供必须的原子特性。实现正确的操作需要使 x 的值在操作期间保持不变，而
volatile 变量无法实现这点。（然而，如果将值调整为只从单个线程写入，那么可以忽略第一个条件。）
大多数编程情形都会与这两个条件的其中之一冲突，使得 volatile
变量不能像 synchronized 那样普遍适用于实现线程安全。清单
1 显示了一个非线程安全的数值范围类。它包含了一个不变式 ——
下界总是小于或等于上界。
参考：
http://www.jianshu.com/p/4377b3245a2c
http://www.ibm.com/developerworks/cn/java/j-jtp06197.html