一般說來，volatile用在如下的幾個地方：

1、中斷服務程序中修改的供其它程序檢測的變量需要加volatile；

　　2、多任務環境下各任務間共享的標志應該加volatile；

　　3、存儲器映射的硬件寄存器通常也要加volatile說明，因為每次對它的讀寫都可能有不同意義；

　　另外，以上這幾種情況經常還要同時考慮數據的完整性（相互關聯的幾個標志讀了一半被打斷了重寫），在1中可以通過關中斷來實現，2 中可以禁止任務調度，3中則只能依靠硬件的良好設計了。

　　volatile關鍵字保證了

　　1. 可見性——在多線程環境下，被修飾的變量在別修改后會馬上同步到主存，這樣該線程對這個變量的修改就是對所有其他線程可見的，其他線程能夠馬上讀到這個修改后值。

　　2. 禁止指令重排序優化

　　本文中來談談第一點，可見性。

　　Thread的本地內存

　　每個Thread都擁有自己的線程存儲空間

　　Thread何時同步本地存儲空間的數據到主存是不確定的

　　例子

　　上圖表示兩個線程并發執行，而且代碼順序上為Thread1-》Thread2

　　不用 volatile

　　假如ready字段不使用volatile，那么Thread 1對ready做出的修改對于Thread2來說未必是可見的，是否可見是不確定的。假如此時thread1 ready泄露了（leak through）了，那么Thread 2可以看見ready為true，但是有可能answer的改變并沒有泄露，則thread2有可能會輸出 0 （answer=42對thread2并不可見）

　　使用 volatile

　　使用volatile以后，做了如下事情

　　每次修改volatile變量都會同步到主存中

　　每次讀取volatile變量的值都強制從主存讀取最新的值（強制JVM不可優化volatile變量，如JVM優化后變量讀取會使用cpu緩存而不從主存中讀?。?/p>

　　線程 A 中寫入 volatile 變量之前可見的變量， 在線程 B 中讀取該 volatile 變量以后， 線程 B 對其他在 A 中的可見變量也可見。 換句話說， 寫 volatile 類似于退出同步塊， 而讀取 volatile 類似于進入同步塊

　　所以如果使用了volatile，那么Thread2讀取到的值為read=》true，answer=》42，當然使用volatile的同時也會增加性能開銷

　　注意

　　volatile并不能保證非源自性操作的多線程安全問題得到解決，volatile解決的是多線程間共享變量的可見性問題，而例如多線程的i++，++i，依然還是會存在多線程問題，它是無法解決了。如下：使用一個線程i++，另一個i–，最終得到的結果不為0

　　public class VolatileTest {

　　private static volatile int count = 0;

　　private static final int times = Integer.MAX_VALUE;

　　public static void main（String［］ args） {

　　long curTime = System.nanoTime（）;

　　Thread decThread = new DecThread（）;

　　decThread.start（）;

　　// 使用run（）來運行結果為0，原因是單線程執行不會有線程安全問題

　　// new DecThread（）.run（）;

　　System.out.println（“Start thread： ” + Thread.currentThread（） + “ i++”）;

　　for （int i = 0; i 《 times; i++） {

　　count++;

　　}

　　System.out.println（“End thread： ” + Thread.currentThread（） + “ i--”）;

　　// 等待decThread結束

　　while （decThread.isAlive（））;

　　long duration = System.nanoTime（） - curTime;

　　System.out.println（“Result： ” + count）;

　　System.out.format（“Duration： %.2fs\n”， duration / 1.0e9）;

　　}

　　private static class DecThread extends Thread {

　　@Override

　　public void run（） {

　　System.out.println（“Start thread： ” + Thread.currentThread（） + “ i--”）;

　　for （int i = 0; i 《 times; i++） {

　　count--;

　　}

　　System.out.println（“End thread： ” + Thread.currentThread（） + “ i--”）;

　　}

　　}

　　}12345678910111213141516171819202122232425262728293031323334353637383940414243

　　最后輸出的結果是

　　Start thread： Thread［main，5，main］ i++

　　Start thread： Thread［Thread-0，5，main］ i--

　　End thread： Thread［main，5，main］ i--

　　End thread： Thread［Thread-0，5，main］ i--

　　Result： -460370604

　　Duration： 67.37s123456

　　原因是i++和++i并非原子操作，我們若查看字節碼，會發現

　　void f1（） { i++; }1

　　的字節碼如下

　　void f1（）;

　　Code：

　　0： aload_0

　　1： dup

　　2： getfield #2; //Field i:I

　　5： iconst_1

　　6： iadd

　　7： putfield #2; //Field i:I

　　10： return123456789

　　可見i++執行了多部操作， 從變量i中讀取讀取i的值 -》 值+1 -》 將+1后的值寫回i中，這樣在多線程的時候執行情況就類似如下了

　　Thread1 Thread2

　　r1 = i; r3 = i;

　　r2 = r1 + 1; r4 = r3 + 1;

　　i = r2; i = r4;1234

　　這樣會造成的問題就是 r1， r3讀到的值都是 0， 最后兩個線程都將 1 寫入 i， 最后 i 等于 1， 但是卻進行了兩次自增操作

　　可知加了volatile和沒加volatile都無法解決非原子操作的線程同步問題

　　線程同步問題的解決

　　Java提供了java.util.concurrent.atomic 包來提供線程安全的基本類型包裝類，例子如下

　　package com.qunar.atomicinteger;

　　import java.util.concurrent.atomic.AtomicInteger;

　　/**

　　* @author zhenwei.liu created on 2013 13-9-2 下午10:18

　　* @version $Id$

　　*/

　　public class SafeTest {

　　private static AtomicInteger count = new AtomicInteger（0）;

　　private static final int times = Integer.MAX_VALUE;

　　public static void main（String［］ args） {

　　long curTime = System.nanoTime（）;

　　Thread decThread = new DecThread（）;

　　decThread.start（）;

　　// 使用run（）來運行結果為0，原因是單線程執行不會有線程安全問題

　　// new DecThread（）.run（）;

　　System.out.println（“Start thread： ” + Thread.currentThread（） + “ i++”）;

　　for （int i = 0; i 《 times; i++） {

　　count.incrementAndGet（）;

　　}

　　// 等待decThread結束

　　while （decThread.isAlive（））;

　　long duration = System.nanoTime（） - curTime;

　　System.out.println（“Result： ” + count）;

　　System.out.format（“Duration： %.2f\n”， duration / 1.0e9）;

　　}

　　private static class DecThread extends Thread {

　　@Override

　　public void run（） {

　　System.out.println（“Start thread： ” + Thread.currentThread（） + “ i--”）;

　　for （int i = 0; i 《 times; i++） {

　　count.decrementAndGet（）;

　　}

　　System.out.println（“End thread： ” + Thread.currentThread（） + “ i--”）;

　　}

　　}

　　}12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849

　　輸出

　　Start thread： Thread［main，5，main］ i++

　　Start thread： Thread［Thread-0，5，main］ i--

　　End thread： Thread［Thread-0，5，main］ i--

　　Result： 0

　　Duration： 105.15