一，volatile關鍵字的可見性

要想理解volatile關鍵字，得先了解下JAVA的記憶體模型，Java記憶體模型的抽象示意圖如下：

從圖中可以看出：

①每個執行緒都有一個自己的本地記憶體空間--執行緒棧空間???執行緒執行時，先把變數從主記憶體讀取到執行緒自己的本地記憶體空間，然後再對該變數進行操作

②對該變數操作完後，在某個時間再把變數重新整理回主記憶體

因此，就存在記憶體可見性問題，看一個示例程式：（摘自書上）

 1 public class RunThread extends Thread {
 2 
 3     private boolean isRunning = true;
 4 
 5     public boolean isRunning() {
 6         return isRunning;
 7     }
 8 
 9     public void setRunning(boolean isRunning) {
10         this.isRunning = isRunning;
11     }
12 
13     @Override
14     public void run() {
15         System.out.println("進入到run方法中了");
16         while (isRunning == true) {
17         }
18         System.out.println("執行緒執行完成了");
19     }
20 }
21 
22 public class Run {
23     public static void main(String[] args) {
24         try {
25             RunThread thread = new RunThread();
26             thread.start();
27             Thread.sleep(1000);
28             thread.setRunning(false);
29         } catch (InterruptedException e) {
30             e.printStackTrace();
31         }
32     }
33 }
 

Run.java 第28行，main執行緒 將啟動的執行緒RunThread中的共享變數設定為false，從而想讓RunThread.java 第14行中的while迴圈結束。

如果，我們使用JVM -server引數執行該程式時，RunThread執行緒並不會終止！從而出現了死迴圈！！

原因分析：

現在有兩個執行緒，一個是main執行緒，另一個是RunThread。它們都試圖修改 第三行的 isRunning變數。按照JVM記憶體模型，main執行緒將isRunning讀取到本地執行緒記憶體空間，修改後，再重新整理回主記憶體。

而在JVM 設定成 -server模式執行程式時，執行緒會一直在私有堆疊中讀取isRunning變數。因此，RunThread執行緒無法讀到main執行緒改變的isRunning變數

從而出現了死迴圈，導致RunThread無法終止。這種情形，在《Effective JAVA》中，將之稱為“活性失敗”

解決方法，在第三行程式碼處用 volatile 關鍵字修飾即可。這裡，它強制執行緒從主記憶體中取 volatile修飾的變數。

    volatile private boolean isRunning = true;

擴充套件一下，當多個執行緒之間需要根據某個條件確定 哪個執行緒可以執行時，要確保這個條件在 執行緒 之間是可見的。因此，可以用volatile修飾。

綜上，volatile關鍵字的作用是：使變數在多個執行緒間可見（可見性）,強制執行緒從主記憶體中讀取。從而保證了多個執行緒的可見性。

二，volatile關鍵字的非原子性

所謂原子性，就是某系列的操作步驟要麼全部執行，要麼都不執行。

比如，變數的自增操作 i++，分三個步驟：

①從記憶體中讀取出變數 i 的值

②將 i 的值加1

③將 加1 後的值寫回記憶體

這說明 i++ 並不是一個原子操作。因為，它分成了三步，有可能當某個執行緒執行到了第②時被中斷了，那麼就意味著只執行了其中的兩個步驟，沒有全部執行。

關於volatile的非原子性，看個示例：

1 public class MyThread extends Thread {
 2     public volatile static int count;
 3 
 4     private static void addCount() {
 5         for (int i = 0; i < 100; i++) {
 6             count++;
 7         }
 8         System.out.println("count=" + count);
 9     }
10 
11     @Override
12     public void run() {
13         addCount();
14     }
15 }
16 
17 public class Run {
18     public static void main(String[] args) {
19         MyThread[] mythreadArray = new MyThread[100];
20         for (int i = 0; i < 100; i++) {
21             mythreadArray[i] = new MyThread();
22         }
23 
24         for (int i = 0; i < 100; i++) {
25             mythreadArray[i].start();
26         }
27     }
28 }

MyThread類第2行，count變數使用volatile修飾

Run.java 第20行 for迴圈中建立了100個執行緒，第25行將這100個執行緒啟動去執行 addCount()，每個執行緒執行100次加1

期望的正確的結果應該是 100*100=10000，但是，實際上count並沒有達到10000

原因是：volatile修飾的變數並不保證對它的操作（自增）具有原子性。（對於自增操作，可以使用JAVA的原子類AutoicInteger類保證原子自增）

比如，假設 i 自增到 5，執行緒A從主記憶體中讀取i，值為5，將它儲存到自己的執行緒空間中，執行加1操作，值為6。此時，CPU切換到執行緒B執行，從主從記憶體中讀取變數i的值。由於執行緒A還沒有來得及將加1後的結果寫回到主記憶體，執行緒B就已經從主記憶體中讀取了i，因此，執行緒B讀到的變數 i 值還是5

相當於執行緒B讀取的是已經過時的資料了，從而導致執行緒不安全性。這種情形在《Effective JAVA》中稱之為“安全性失敗”

綜上，僅靠volatile不能保證執行緒的安全性。（原子性）

此外，volatile關鍵字修飾的變數不會被指令重排序優化。這裡以《深入理解JAVA虛擬機器》中一個例子來說明下自己的理解：

執行緒A執行的操作如下：

Map configOptions ;
char[] configText;

volatile boolean initialized = false;

//執行緒A首先從檔案中讀取配置資訊,呼叫process...處理配置資訊,處理完成了將initialized 設定為true
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfig(configText, configOptions);//負責將配置資訊configOptions 成功初始化
initialized = true;

執行緒B等待執行緒A把配置資訊初始化成功後，使用配置資訊去幹活.....執行緒B執行的操作如下：

while(!initialized)
{
    sleep();
}

//使用配置資訊幹活
doSomethingWithConfig();

如果initialized變數不用 volatile 修飾，線上程A執行的程式碼中就有可能指令重排序。

即：執行緒A執行的程式碼中的最後一行：initialized = true 重排序到了 processConfig方法呼叫的前面執行了，這就意味著：配置資訊還未成功初始化，但是initialized變數已經被設定成true了。那麼就導致 執行緒B的while迴圈“提前”跳出，拿著一個還未成功初始化的配置資訊去幹活(doSomethingWithConfig方法)。。。。

因此，initialized 變數就必須得用 volatile修飾。這樣，就不會發生指令重排序，也即：只有當配置資訊被執行緒A成功初始化之後，initialized 變數才會初始化為true。綜上，volatile 修飾的變數會禁止指令重排序（有序性）

三，volatile 與 synchronized 的比較

volatile主要用在多個執行緒感知例項變數被更改了場合，從而使得各個執行緒獲得最新的值。它強制執行緒每次從主記憶體中講到變數，而不是從執行緒的私有記憶體中讀取變數，從而保證了資料的可見性。

比較：

①volatile輕量級，只能修飾變數。synchronized重量級，還可修飾方法

②volatile只能保證資料的可見性，不能用來同步，因為多個執行緒併發訪問volatile修飾的變數不會阻塞。

synchronized不僅保證可見性，而且還保證原子性，因為，只有獲得了鎖的執行緒才能進入臨界區，從而保證臨界區中的所有語句都全部執行。多個執行緒爭搶synchronized鎖物件時，會出現阻塞。