Java volatile的適用場景實例詳解

把代碼塊聲明為 synchronized，有兩個重要后果，通常是指該代碼具有 原子性（atomicity）和 可見性（visibility）。

• 原子性意味著個時刻，只有一個線程能夠執行一段代碼，這段代碼通過一個monitor object保護。從而防止多個線程在更新共享狀態時相互沖突。
• 可見性則更為微妙，它必須確保釋放鎖之前對共享數據做出的更改對于隨后獲得該鎖的另一個線程是可見的。 —— 如果沒有同步機制提供的這種可見性保證，線程看到的共享變量可能是修改前的值或不一致的值，這將引發許多嚴重問題。
  

volatile的使用條件

Volatile 變量具有 synchronized 的可見性特性，但是不具備原子性。這就是說線程能夠自動發現 volatile 變量的最新值。

Volatile 變量可用于提供線程安全，但是只能應用于非常有限的一組用例：多個變量之間或者某個變量的當前值與修改后值之間沒有約束。因此，單獨使用 volatile 還不足以實現計數器、互斥鎖或任何具有與多個變量相關的不變式（Invariants）的類（例如 “start <=end”）。

出于簡易性或可伸縮性的考慮，您可能傾向于使用 volatile 變量而不是鎖。當使用 volatile 變量而非鎖時，某些習慣用法（idiom）更加易于編碼和閱讀。此外，volatile 變量不會像鎖那樣造成線程阻塞，因此也很少造成可伸縮性問題。在某些情況下，如果讀操作遠遠大于寫操作，volatile 變量還可以提供優于鎖的性能優勢。

使用條件

您只能在有限的一些情形下使用 volatile 變量替代鎖。要使 volatile 變量提供理想的線程安全，必須同時滿足下面兩個條件：

• 對變量的寫操作不依賴于當前值。
• 該變量沒有包含在具有其他變量的不變式中。
  

實際上，這些條件表明，可以被寫入 volatile 變量的這些有效值獨立于任何程序的狀態，包括變量的當前狀態。

第一個條件的限制使 volatile 變量不能用作線程安全計數器。雖然增量操作（x++）看上去類似一個單獨操作，實際上它是一個由（讀取－修改－寫入）操作序列組成的組合操作，必須以原子方式執行，而 volatile 不能提供必須的原子特性。實現正確的操作需要使x 的值在操作期間保持不變，而 volatile 變量無法實現這點。（然而，如果只從單個線程寫入，那么可以忽略第一個條件。）

反例

大多數編程情形都會與這兩個條件的其中之一沖突，使得 volatile 變量不能像 synchronized 那樣普遍適用于實現線程安全。

【反例：volatile變量不能用于約束條件中】 下面是一個非線程安全的數值范圍類。它包含了一個不變式 —— 下界總是小于或等于上界

@NotThreadSafe 
public class NumberRange {
  private int lower, upper;
 
  public int getLower() { return lower; }
  public int getUpper() { return upper; }
 
  public void setLower(int value) { 
    if (value > upper) 
      throw new IllegalArgumentException(...);
    lower = value;
  }
 
  public void setUpper(int value) { 
    if (value < lower) 
      throw new IllegalArgumentException(...);
    upper = value;
  }
}

將 lower 和 upper 字段定義為 volatile 類型不能夠充分實現類的線程安全；而仍然需要使用同步——使 setLower() 和 setUpper() 操作原子化。

否則，如果湊巧兩個線程在同一時間使用不一致的值執行 setLower 和 setUpper 的話，則會使范圍處于不一致的狀態。例如，如果初始狀態是(0, 5)，同一時間內，線程 A 調用setLower(4) 并且線程 B 調用setUpper(3)，顯然這兩個操作交叉存入的值是不符合條件的，那么兩個線程都會通過用于保護不變式的檢查，使得最后的范圍值是(4, 3) —— 一個無效值。

volatile的適用場景

模式 #1：狀態標志

也許實現 volatile 變量的規范使用僅僅是使用一個布爾狀態標志，用于指示發生了一個重要的一次性事件，例如完成初始化或請求停機。

volatile boolean shutdownRequested;
 
...
 
public void shutdown() { 
  shutdownRequested = true; 
}
 
public void doWork() { 
  while (!shutdownRequested) { 
    // do stuff
  }
}

線程1執行doWork()的過程中，可能有另外的線程2調用了shutdown，所以boolean變量必須是volatile。

而如果使用 synchronized 塊編寫循環要比使用 volatile 狀態標志編寫麻煩很多。由于 volatile 簡化了編碼，并且狀態標志并不依賴于程序內任何其他狀態，因此此處非常適合使用 volatile。

這種類型的狀態標記的一個公共特性是：通常只有一種狀態轉換；shutdownRequested 標志從false 轉換為true，然后程序停止。這種模式可以擴展到來回轉換的狀態標志，但是只有在轉換周期不被察覺的情況下才能擴展（從false 到true，再轉換到false）。此外，還需要某些原子狀態轉換機制，例如原子變量。

模式 #2：一次性安全發布（one-time safe publication）

在缺乏同步的情況下，可能會遇到某個對象引用的更新值（由另一個線程寫入）和該對象狀態的舊值同時存在。

這就是造成著名的雙重檢查鎖定（double-checked-locking）問題的根源，其中對象引用在沒有同步的情況下進行讀操作，產生的問題是您可能會看到一個更新的引用，但是仍然會通過該引用看到不完全構造的對象。

//注意volatile！！！！！！！！！！！！！！！！！ 
private volatile static Singleton instace;  
 
public static Singleton getInstance(){  
  //第一次null檢查   
  if(instance == null){      
    synchronized(Singleton.class) {  //1   
      //第二次null檢查    
      if(instance == null){     //2 
        instance = new Singleton();//3 
      } 
    }      
  } 
  return instance;    

如果不用volatile，則因為內存模型允許所謂的“無序寫入”，可能導致失敗。——某個線程可能會獲得一個未完全初始化的實例。

考察上述代碼中的 //3 行。此行代碼創建了一個 Singleton 對象并初始化變量 instance 來引用此對象。這行代碼的問題是：在Singleton 構造函數體執行之前，變量instance 可能成為非 null 的！
什么？這一說法可能讓您始料未及，但事實確實如此。

在解釋這個現象如何發生前，請先暫時接受這一事實，我們先來考察一下雙重檢查鎖定是如何被破壞的。假設上述代碼執行以下事件序列：

1. 線程 1 進入 getInstance() 方法。
2. 由于 instance 為 null，線程 1 在 //1 處進入synchronized 塊。
3. 線程 1 前進到 //3 處，但在構造函數執行之前，使實例成為非null。
4. 線程 1 被線程 2 預占。
5. 線程 2 檢查實例是否為 null。因為實例不為 null，線程 2 將instance 引用返回，返回一個構造完整但部分初始化了的Singleton 對象。
6. 線程 2 被線程 1 預占。
7. 線程 1 通過運行 Singleton 對象的構造函數并將引用返回給它，來完成對該對象的初始化。

模式 #3：獨立觀察（independent observation）

安全使用 volatile 的另一種簡單模式是：定期 “發布” 觀察結果供程序內部使用。【例如】假設有一種環境傳感器能夠感覺環境溫度。一個后臺線程可能會每隔幾秒讀取一次該傳感器，并更新包含當前文檔的 volatile 變量。然后，其他線程可以讀取這個變量，從而隨時能夠看到最新的溫度值。

使用該模式的另一種應用程序就是收集程序的統計信息。【例】如下代碼展示了身份驗證機制如何記憶最近一次登錄的用戶的名字。將反復使用lastUser 引用來發布值，以供程序的其他部分使用。

public class UserManager {
  public volatile String lastUser; //發布的信息
 
  public boolean authenticate(String user, String password) {
    boolean valid = passwordIsValid(user, password);
    if (valid) {
      User u = new User();
      activeUsers.add(u);
      lastUser = user;
    }
    return valid;
  }
} 

模式 #4：“volatile bean” 模式

volatile bean 模式的基本原理是：很多框架為易變數據的持有者（例如 HttpSession）提供了容器，但是放入這些容器中的對象必須是線程安全的。

在 volatile bean 模式中，JavaBean 的所有數據成員都是 volatile 類型的，并且 getter 和 setter 方法必須非常普通——即不包含約束！

@ThreadSafe
public class Person {
  private volatile String firstName;
  private volatile String lastName;
  private volatile int age;
 
  public String getFirstName() { return firstName; }
  public String getLastName() { return lastName; }
  public int getAge() { return age; }
 
  public void setFirstName(String firstName) { 
    this.firstName = firstName;
  }
 
  public void setLastName(String lastName) { 
    this.lastName = lastName;
  }
 
  public void setAge(int age) { 
    this.age = age;
  }
}

模式 #5：開銷較低的“讀－寫鎖”策略
如果讀操作遠遠超過寫操作，您可以結合使用內部鎖和 volatile 變量來減少公共代碼路徑的開銷。

如下顯示的線程安全的計數器，使用 synchronized 確保增量操作是原子的，并使用 volatile 保證當前結果的可見性。如果更新不頻繁的話，該方法可實現更好的性能，因為讀路徑的開銷僅僅涉及 volatile 讀操作，這通常要優于一個無競爭的鎖獲取的開銷。

@ThreadSafe
public class CheesyCounter {
  // Employs the cheap read-write lock trick
  // All mutative operations MUST be done with the 'this' lock held
  @GuardedBy("this") private volatile int value;
 
  //讀操作，沒有synchronized，提高性能
  public int getValue() { 
    return value; 
  } 
 
  //寫操作，必須synchronized。因為x++不是原子操作
  public synchronized int increment() {
    return value++;
  }

使用鎖進行所有變化的操作，使用 volatile 進行只讀操作。

其中，鎖一次只允許一個線程訪問值，volatile 允許多個線程執行讀操作