用在多线程，同步变量。 线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm， 它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A) 

=========================分割线1================================= 

版权声明 ：转载时请以超链接形式标明文章原始出处和作者信息及本声明

http://blog.csdn.net/orzorz/archive/2009/07/03/4319055.aspx 

在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。 

一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。以下例子展现了volatile的作用： 

 1 public class StoppableTask extends Thread { 2  3   private volatile boolean pleaseStop; 4  5  6   public void run() { 7  8     while (!pleaseStop) { 9 10      // do some stuff...11 12     }13 14  }15 16 17   public void tellMeToStop() {18 19    pleaseStop = true;20 21   }22 23 }

Volatile一般情况下不能代替sychronized，因为volatile不能保证操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。如果配合Java 5增加的atomic wrapper classes，对它们的increase之类的操作就不需要sychronized。 

Reference： 
http://www.javamex.com/tutorials/synchronization_volatile.shtml 
http://www.javamex.com/tutorials/synchronization_volatile_java_5.shtml 
http://www.ibm.com/developerworks/cn/java/j-jtp06197.html 
=========================分割线2================================= 

  恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码： 

1 int i1;             2 int geti1() {return i1;} 3 volatile int i2; 4 int geti2()5 {return i2;} 6 int i3;              7 synchronized int geti3() {return i3;} 

　　得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。 

　　而 geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。 
　　既然volatile关键字已经实现了线程间数据同步，又要 synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“ 主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步： 
1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放） 
2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]） 
3. 代码块被执行 
4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值） 
5. 线程释放监视this对象的对象锁 
　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。 

=========================分割线3================================= 

volatile关键字相信了解Java多线程的读者都很清楚它的作用。volatile关键字用于声明简单类型变量，如int、float、 boolean等数据类型。如果这些简单数据类型声明为volatile，对它们的操作就会变成原子级别的。但这有一定的限制。例如，下面的例子中的n就不是原子级别的： 

 1 public class JoinThread extends Thread { 2     public static volatile int n = 0; 3  4     public void run() { 5         for (int i = 0; i < 10; i++) 6             try { 7                 n = n + 1; 8                 sleep(3); // 为了使运行结果更随机，延迟3毫秒 9 10             } catch (Exception e) {11             }12     }13 14     public static void main(String[] args) throws Exception {15 16         Thread threads[] = new Thread[100];17         for (int i = 0; i < threads.length; i++)18             // 建立100个线程19             threads[i] = new JoinThread();20         for (int i = 0; i < threads.length; i++)21             // 运行刚才建立的100个线程22             threads[i].start();23         for (int i = 0; i < threads.length; i++)24             // 100个线程都执行完后继续25             threads[i].join();26         System.out.println(" n= " + JoinThread.n);27     }28 }

如果对n的操作是原子级别的，最后输出的结果应该为n=1000，而在执行上面积代码时，很多时侯输出的n都小于1000，这说明n=n+1不是原子级别的操作。原因是声明为volatile的简单变量如果当前值由该变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作： 

n  =  n  +   1 ; 
n ++ ; 

      如果要想使这种情况变成原子操作，需要使用synchronized关键字，如上的代码可以改成如下的形式： 

 1 public class JoinThread extends Thread { 2     public static int n = 0; 3  4     public static synchronized void inc() { 5         n++; 6     } 7  8     public void run() { 9         for (int i = 0; i < 10; i++)10             try {11                 inc(); // n = n + 1 改成了 inc();12                 sleep(3); // 为了使运行结果更随机，延迟3毫秒13 14             } catch (Exception e) {15             }16     }17 18     public static void main(String[] args) throws Exception {19 20         Thread threads[] = new Thread[100];21         for (int i = 0; i < threads.length; i++)22             // 建立100个线程23             threads[i] = new JoinThread();24         for (int i = 0; i < threads.length; i++)25             // 运行刚才建立的100个线程26             threads[i].start();27         for (int i = 0; i < threads.length; i++)28             // 100个线程都执行完后继续29             threads[i].join();30         System.out.println(" n= " + JoinThread.n);31     }32 }

[转]Java学习日记之 volatile