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

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

volatile的使用條件

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

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

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

使用條件

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

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

實(shí)際上，這些條件表明，可以被寫入 volatile 變量的這些有效值獨(dú)立于任何程序的狀態(tài)，包括變量的當(dāng)前狀態(tài)。

第一個條件的限制使 volatile 變量不能用作線程安全計數(shù)器。雖然增量操作（x++）看上去類似一個單獨(dú)操作，實(shí)際上它是一個由（讀?。薷模瓕懭耄┎僮餍蛄薪M成的組合操作，必須以原子方式執(zhí)行，而 volatile 不能提供必須的原子特性。實(shí)現(xiàn)正確的操作需要使x 的值在操作期間保持不變，而 volatile 變量無法實(shí)現(xiàn)這點(diǎn)。（然而，如果只從單個線程寫入，那么可以忽略第一個條件。）

反例

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

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

@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 類型不能夠充分實(shí)現(xiàn)類的線程安全；而仍然需要使用同步——使 setLower() 和 setUpper() 操作原子化。

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

volatile的適用場景

模式 #1：狀態(tài)標(biāo)志

也許實(shí)現(xiàn) volatile 變量的規(guī)范使用僅僅是使用一個布爾狀態(tài)標(biāo)志，用于指示發(fā)生了一個重要的一次性事件，例如完成初始化或請求停機(jī)。

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

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

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

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

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

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

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

//注意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，則因?yàn)閮?nèi)存模型允許所謂的“無序?qū)懭搿?，可能?dǎo)致失敗?！硞€線程可能會獲得一個未完全初始化的實(shí)例。

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

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

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

模式 #3：獨(dú)立觀察（independent observation）

安全使用 volatile 的另一種簡單模式是：定期 “發(fā)布” 觀察結(jié)果供程序內(nèi)部使用?！纠纭考僭O(shè)有一種環(huán)境傳感器能夠感覺環(huán)境溫度。一個后臺線程可能會每隔幾秒讀取一次該傳感器，并更新包含當(dāng)前文檔的 volatile 變量。然后，其他線程可以讀取這個變量，從而隨時能夠看到最新的溫度值。

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

public class UserManager {
  public volatile String lastUser; //發(fā)布的信息
 
  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 模式的基本原理是：很多框架為易變數(shù)據(jù)的持有者（例如 HttpSession）提供了容器，但是放入這些容器中的對象必須是線程安全的。

在 volatile bean 模式中，JavaBean 的所有數(shù)據(jù)成員都是 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：開銷較低的“讀－寫鎖”策略
如果讀操作遠(yuǎn)遠(yuǎn)超過寫操作，您可以結(jié)合使用內(nèi)部鎖和 volatile 變量來減少公共代碼路徑的開銷。

如下顯示的線程安全的計數(shù)器，使用 synchronized 確保增量操作是原子的，并使用 volatile 保證當(dāng)前結(jié)果的可見性。如果更新不頻繁的話，該方法可實(shí)現(xiàn)更好的性能，因?yàn)樽x路徑的開銷僅僅涉及 volatile 讀操作，這通常要優(yōu)于一個無競爭的鎖獲取的開銷。

@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。因?yàn)閤++不是原子操作
  public synchronized int increment() {
    return value++;
  }

使用鎖進(jìn)行所有變化的操作，使用 volatile 進(jìn)行只讀操作。

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

最新評論