happen—before規則介紹

    Java語言中有一個“先行發生”（happen—before）的規則，它是Java記憶體模型中定義的兩項操作之間的偏序關係，如果操作A先行發生於操作B，其意思就是說，在發生操作B之前，操作A產生的影響都能被操作B觀察到，“影響”包括修改了記憶體中共享變數的值、傳送了訊息、呼叫了方法等，它與時間上的先後發生基本沒有太大關係。這個原則特別重要，它是判斷資料是否存在競爭、執行緒是否安全的主要依據。

舉例來說，假設存在如下三個執行緒，分別執行對應的操作:

---------------------------------------------------------------------------

執行緒A中執行如下操作：i=1

執行緒B中執行如下操作：j=i

執行緒C中執行如下操作：i=2

---------------------------------------------------------------------------

    假設執行緒A中的操作”i=1“ happen—before執行緒B中的操作“j=i”，那麼就可以保證線上程B的操作執行後，變數j的值一定為1，即執行緒B觀察到了執行緒A中操作“i=1”所產生的影響；現在，我們依然保持執行緒A和執行緒B之間的happen—before關係，同時執行緒C出現在了執行緒A和執行緒B的操作之間，但是C與B並沒有happen—before關係，那麼j的值就不確定了，執行緒C對變數i的影響可能會被執行緒B觀察到，也可能不會，這時執行緒B就存在讀取到不是最新資料的風險，不具備執行緒安全性。

    下面是Java記憶體模型中的八條可保證happen—before的規則，它們無需任何同步器協助就已經存在，可以在編碼中直接使用。如果兩個操作之間的關係不在此列，並且無法從下列規則推匯出來的話，它們就沒有順序性保障，虛擬機器可以對它們進行隨機地重排序。

    1、程式次序規則：在一個單獨的執行緒中，按照程式程式碼的執行流順序，（時間上）先執行的操作happen—before（時間上）後執行的操作。

    2、管理鎖定規則：一個unlock操作happen—before後面（時間上的先後順序，下同）對同一個鎖的lock操作。

    3、volatile變數規則：對一個volatile變數的寫操作happen—before後面對該變數的讀操作。

    4、執行緒啟動規則：Thread物件的start（）方法happen—before此執行緒的每一個動作。

    5、執行緒終止規則：執行緒的所有操作都happen—before對此執行緒的終止檢測，可以通過Thread.join（）方法結束、Thread.isAlive（）的返回值等手段檢測到執行緒已經終止執行。

    6、執行緒中斷規則：對執行緒interrupt（）方法的呼叫happen—before發生於被中斷執行緒的程式碼檢測到中斷時事件的發生。

    7、物件終結規則：一個物件的初始化完成（建構函式執行結束）happen—before它的finalize（）方法的開始。

    8、傳遞性：如果操作A happen—before操作B，操作B happen—before操作C，那麼可以得出A happen—before操作C。

時間上先後順序和happen—before原則

    1、首先來看操作A在時間上先與操作B發生，是否意味著操作A happen—before操作B？

    一個常用來分析的例子如下：

	private int value = 0;

	public int get(){
		return value;
	}
	public void set(int value){
		this.value = value;
	}
}

    對照以上八條happen—before規則，發現沒有一條規則適合於這裡的value變數，從而我們可以判定執行緒A中的setValue（3）操作與執行緒B中的getValue（）操作不存在happen—before關係。因此，儘管執行緒A的setValue（3）在操作時間上先於操作B的getvalue（），但無法保證執行緒B的getValue（）操作一定觀察到了執行緒A的setValue（3）操作所產生的結果，也即是getValue（）的返回值不一定為3（有可能是之前setValue所設定的值）。這裡的操作不是執行緒安全的。

    因此，”一個操作時間上先發生於另一個操作“並不代表”一個操作happen—before另一個操作“。

    解決方法：可以將setValue（int）方法和getValue（）方法均定義為synchronized方法，也可以把value定義為volatile變數（value的修改並不依賴value的原值，符合volatile的使用場景），分別對應happen—before規則的第2和第3條。注意，只將setValue（int）方法和getvalue（）方法中的一個定義為synchronized方法是不行的，必須對同一個變數的所有讀寫同步，才能保證不讀取到陳舊的資料，僅僅同步讀或寫是不夠的 。

    2、其次來看，操作A happen—before操作B，是否意味著操作A在時間上先與操作B發生？

    看有如下程式碼：

x = 1；
y = 2;

    因此，”一個操作happen—before另一個操作“並不代表”一個操作時間上先發生於另一個操作“。

最後，一個操作和另一個操作必定存在某個順序，要麼一個操作或者是先於或者是後於另一個操作，或者與兩個操作同時發生。同時發生是完全可能存在的，特別是在多CPU的情況下。而兩個操作之間卻可能沒有happen-before關係，也就是說有可能發生這樣的情況，操作A不happen-before操作B，操作B也不happen-before操作A，用數學上的術語happen-before關係是個偏序關係。兩個存在happen-before關係的操作不可能同時發生，一個操作A happen-before操作B，它們必定在時間上是完全錯開的，這實際上也是同步的語義之一（獨佔訪問）。

利用happen—before規則分析DCL

public class LazySingleton {
    private int someField;
    
    private static LazySingleton instance;
    
    private LazySingleton() {
        this.someField = new Random().nextInt(200)+1;         // (1)
    }
    
    public static LazySingleton getInstance() {
        if (instance == null) {                               // (2)
            synchronized(LazySingleton.class) {               // (3)
                if (instance == null) {                       // (4)
                    instance = new LazySingleton();           // (5)
                }
            }
        }
        return instance;                                      // (6)
    }
    
    public int getSomeField() {
        return this.someField;                                // (7)
    }
}

public class Singleton {

  private Singleton() {}

  // Lazy initialization holder class idiom for static fields
  private static class InstanceHolder {
   private static final Singleton instance = new Singleton();
  }

  public static Singleton getSingleton() { 
    return InstanceHolder.instance; 
  }
}

    這樣我們便可以得到，執行緒Ⅰ的語句(5) -> 語執行緒Ⅱ的句(2)，根據單執行緒規則，執行緒Ⅰ的語句(1) -> 執行緒Ⅰ的語句(5)和語執行緒Ⅱ的句(2) -> 語執行緒Ⅱ的句(7)，再根據傳遞規則就有執行緒Ⅰ的語句(1) -> 語執行緒Ⅱ的句(7)，這表示執行緒Ⅱ能夠觀察到執行緒Ⅰ在語句(1)時對someFiled的寫入值，程式能夠得到正確的行為。

   注：

    1、volatile遮蔽指令重排序的語義在JDK1.5中才被完全修復，此前的JDK中及時將變數宣告為volatile，也仍然不能完全避免重排序所導致的問題（主要是volatile變數前後的程式碼仍然存在重排序問題），這點也是在JDK1.5之前的Java中無法安全使用DCL來實現單例模式的原因。

    2、把volatile寫和volatile讀這兩個操作綜合起來看，在讀執行緒B讀一個volatile變數後，寫執行緒A在寫這個volatile變數之前，所有可見的共享變數的值都將立即變得對讀執行緒B可見。

   3、 在java5之前對final欄位的同步語義和其它變數沒有什麼區別，在java5中，final變數一旦在建構函式中設定完成（前提是在建構函式中沒有洩露this引用)，其它執行緒必定會看到在建構函式中設定的值。而DCL的問題正好在於看到物件的成員變數的預設值，因此我們可以將LazySingleton的someField變數設定成final，這樣在java5中就能夠正確運行了。

                 《深入理解Java虛擬機器——JVM高階特性與最佳實踐》第12章