volatile讓變量每次在使用的時候，都從主存中取。而不是從各個線程的“工作內存”。
volatile具有synchronized關鍵字的“可見性”，但是沒有synchronized關鍵字的“併發正確性”，也就是說不保證線程執行的有序性。
也就是說，volatile變量對於每次使用，線程都能得到當前volatile變量的最新值。但是volatile變量並不保證併發的正確性。
=========================分割線1=================================
在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 }
假如pleaseStop沒有被聲明爲volatile，線程執行run的時候檢查的是自己的副本，就不能及時得知其他線程已經調用tellMeToStop()修改了pleaseStop的值。
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特性：
volatile具有可見性、有序性，不具備原子性。
注意，volatile不具備原子性，這是volatile與java中的synchronized、java.util.concurrent.locks.Lock最大的功能差異，這一點在面試中也是非常容易問到的點。
下面來分別看下可見性、有序性、原子性：
原子性：如果你瞭解事務，那這個概念應該好理解。原子性通常指多個操作不存在只執行一部分的情況，如果全部執行完成那沒毛病，如果只執行了一部分，那對不起，你得撤銷(即事務中的回滾)已經執行的部分。
可見性：當多個線程訪問同一個變量x時，線程1修改了變量x的值，線程1、線程2...線程n能夠立即讀取到線程1修改後的值。
有序性：即程序執行時按照代碼書寫的先後順序執行。在Java內存模型中，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到單線程程序的執行，卻會影響到多線程併發執行的正確性。(本文不對指令重排作介紹，但不代表它不重要，它是理解JAVA併發原理時非常重要的一個概念)。
volatile適用場景：
適用於對變量的寫操作不依賴於當前值，對變量的讀取操作不依賴於非volatile變量。適用於讀多寫少的場景。可用作狀態標誌。JDK中volatie應用：JDK中ConcurrentHashMap的Entry的value和next被聲明爲volatile，AtomicLong中的value被聲明爲volatile。AtomicLong通過CAS原理(也可以理解爲樂觀鎖)保證了原子性。
volatile VS synchronized
volatilesynchronized修飾對象修飾變量修飾方法或代碼段可見性11有序性11原子性01線程阻塞01對比這個表格，你會不會覺得synchronized完勝volatile，答案是否定的，volatile不會讓線程阻塞，響應速度比synchronized高，這是它的優點。
恐怕比較一下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;}
8 geti1()
得到存儲在當前線程中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 package mythread;
2
3 public class JoinThread extends Thread
4 {
5 public static volatile int n = 0 ;
6 public void run()
7 {
8 for ( int i = 0 ; i < 10 ; i ++ )
9 try
10 {
11 n = n + 1 ;
12 sleep( 3 ); // 爲了使運行結果更隨機，延遲3毫秒
13
14 }
15 catch (Exception e)
16 {
17 }
18 }
19
20 public static void main(String[] args) throws Exception
21 {
22
23 Thread threads[] = new Thread[ 100 ];
24 for ( int i = 0 ; i < threads.length; i ++ )
25 // 建立100個線程
26 threads[i] = new JoinThread();
27 for ( int i = 0 ; i < threads.length; i ++ )
28 // 運行剛纔建立的100個線程
29 threads[i].start();
30 for ( int i = 0 ; i < threads.length; i ++ )
31 // 100個線程都執行完後繼續
32 threads[i].join();
33 System.out.println( " n= " + JoinThread.n);
34 }
35 }
如果對n的操作是原子級別的，最後輸出的結果應該爲n=1000，而在執行上面積代碼時，很多時侯輸出的n都小於1000，這說明n=n+1不是原子級別的操作。原因是聲明爲volatile的簡單變量如果當前值由該變量以前的值相關，那麼volatile關鍵字不起作用，也就是說如下的表達式都不是原子操作：
n = n + 1 ;
n ++ ;
如果要想使這種情況變成原子操作，需要使用synchronized關鍵字，如上的代碼可以改成如下的形式：
package mythread;
public class JoinThread extends Thread
{
public static int n = 0 ;
public static synchronized void inc()
{
n ++ ;
}
public void run()
{
for ( int i = 0 ; i < 10 ; i ++ )
try
{
inc(); // n = n + 1 改成了 inc();
sleep( 3 ); // 爲了使運行結果更隨機，延遲3毫秒
}
catch (Exception e)
{
}
}
public static void main(String[] args) throws Exception
{
Thread threads[] = new Thread[ 100 ];
for ( int i = 0 ; i < threads.length; i ++ )
// 建立100個線程
threads[i] = new JoinThread();
for ( int i = 0 ; i < threads.length; i ++ )
// 運行剛纔建立的100個線程
threads[i].start();
for ( int i = 0 ; i < threads.length; i ++ )
// 100個線程都執行完後繼續
threads[i].join();
System.out.println( " n= " + JoinThread.n);
}
}
上面的代碼將n=n+1改成了inc()，其中inc方法使用了synchronized關鍵字進行方法同步。因此，在使用volatile關鍵字時要慎重，並不是只要簡單類型變量使用volatile修飾，對這個變量的所有操作都是原來操作，當變量的值由自身的上一個決定時，如n=n+1、n++ 等，volatile關鍵字將失效，只有當變量的值和自身上一個值無關時對該變量的操作纔是原子級別的，如n = m + 1，這個就是原級別的。所以在使用volatile關鍵時一定要謹慎，如果自己沒有把握，可以使用synchronized來代替volatile。