漫畫：什麼是單例模式？

程式設計師小灰發表於2018-01-19

————— 第二天 —————

單例模式第一版：

public class Singleton {
    private Singleton() {}  //私有建構函式
    private static Singleton instance = null;  //單例物件
    //靜態工廠方法
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}


複製程式碼

為什麼這樣寫呢？我們來解釋幾個關鍵點：

1.要想讓一個類只能構建一個物件，自然不能讓它隨便去做new操作，因此Signleton的構造方法是私有的。

2.instance是Singleton類的靜態成員，也是我們的單例物件。它的初始值可以寫成Null，也可以寫成new Singleton()。至於其中的區別後來會做解釋。

3.getInstance是獲取單例物件的方法。

如果單例初始值是null，還未構建，則構建單例物件並返回。這個寫法屬於單例模式當中的懶漢模式。

如果單例物件一開始就被new Singleton()主動構建，則不再需要判空操作，這種寫法屬於餓漢模式。

這兩個名字很形象：餓漢主動找食物吃，懶漢躺在地上等著人喂。

為什麼說剛才的程式碼不是執行緒安全呢？

假設Singleton類剛剛被初始化，instance物件還是空，這時候兩個執行緒同時訪問getInstance方法：

因為Instance是空，所以兩個執行緒同時通過了條件判斷，開始執行new操作：

這樣一來，顯然instance被構建了兩次。讓我們對程式碼做一下修改：

單例模式第二版：

public class Singleton {
    private Singleton() {}  //私有建構函式
   private static Singleton instance = null;  //單例物件
   //靜態工廠方法
   public static Singleton getInstance() {
        if (instance == null) {      //雙重檢測機制
         synchronized (Singleton.class){  //同步鎖
           if (instance == null) {     //雙重檢測機制
             instance = new Singleton();
               }
            }
         }
        return instance;
    }
}
複製程式碼

為什麼這樣寫呢？我們來解釋幾個關鍵點：

1.為了防止new Singleton被執行多次，因此在new操作之前加上Synchronized 同步鎖，鎖住整個類（注意，這裡不能使用物件鎖）。

2.進入Synchronized 臨界區以後，還要再做一次判空。因為當兩個執行緒同時訪問的時候，執行緒A構建完物件，執行緒B也已經通過了最初的判空驗證，不做第二次判空的話，執行緒B還是會再次構建instance物件。

像這樣兩次判空的機制叫做雙重檢測機制。

————————————

假設這樣的場景，當兩個執行緒一先一後訪問getInstance方法的時候，當A執行緒正在構建物件，B執行緒剛剛進入方法：

這種情況表面看似沒什麼問題，要麼Instance還沒被執行緒A構建，執行緒B執行 if（instance == null）的時候得到true；要麼Instance已經被執行緒A構建完成，執行緒B執行 if（instance == null）的時候得到false。

真的如此嗎？答案是否定的。這裡涉及到了JVM編譯器的指令重排。

指令重排是什麼意思呢？比如java中簡單的一句 instance = new Singleton，會被編譯器編譯成如下JVM指令：

memory =allocate(); //1：分配物件的記憶體空間

ctorInstance(memory); //2：初始化物件

instance =memory; //3：設定instance指向剛分配的記憶體地址

但是這些指令順序並非一成不變，有可能會經過JVM和CPU的優化，指令重排成下面的順序：

memory =allocate(); //1：分配物件的記憶體空間

instance =memory; //3：設定instance指向剛分配的記憶體地址

ctorInstance(memory); //2：初始化物件

當執行緒A執行完1,3,時，instance物件還未完成初始化，但已經不再指向null。此時如果執行緒B搶佔到CPU資源，執行 if（instance == null）的結果會是false，從而返回一個沒有初始化完成的instance物件。如下圖所示：

如何避免這一情況呢？我們需要在instance物件前面增加一個修飾符volatile。

單例模式第三版：

public class Singleton {
    private Singleton() {}  //私有建構函式
    private volatile static Singleton instance = null;  //單例物件
    //靜態工廠方法
    public static Singleton getInstance() {
          if (instance == null) {      //雙重檢測機制
         synchronized (Singleton.class){  //同步鎖
           if (instance == null) {     //雙重檢測機制
             instance = new Singleton();
                }
             }
          }
          return instance;
      }
}複製程式碼

The volatile keyword indicates that a value may change between different accesses, it prevents an optimizing compiler from optimizing away subsequent reads or writes and thus incorrectly reusing a stale value or omitting writes.

經過volatile的修飾，當執行緒A執行instance = new Singleton的時候，JVM執行順序是什麼樣？始終保證是下面的順序：

memory =allocate(); //1：分配物件的記憶體空間

ctorInstance(memory); //2：初始化物件

instance =memory; //3：設定instance指向剛分配的記憶體地址

如此線上程B看來，instance物件的引用要麼指向null，要麼指向一個初始化完畢的Instance，而不會出現某個中間態，保證了安全。

用靜態內部類實現單例模式：

public class Singleton {
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}複製程式碼

這裡有幾個需要注意的點：

1.從外部無法訪問靜態內部類LazyHolder，只有當呼叫Singleton.getInstance方法的時候，才能得到單例物件INSTANCE。

2.INSTANCE物件初始化的時機並不是在單例類Singleton被載入的時候，而是在呼叫getInstance方法，使得靜態內部類LazyHolder被載入的時候。因此這種實現方式是利用classloader的載入機制來實現懶載入，並保證構建單例的執行緒安全。

如何利用反射打破單例模式的約束？其實很簡單，我們來看下程式碼。

利用反射打破單例：

//獲得構造器
Constructor con = Singleton.class.getDeclaredConstructor();
//設定為可訪問
con.setAccessible(true);
//構造兩個不同的物件
Singleton singleton1 = (Singleton)con.newInstance();
Singleton singleton2 = (Singleton)con.newInstance();
//驗證是否是不同物件
System.out.println(singleton1.equals(singleton2));複製程式碼

程式碼可以簡單歸納為三個步驟：

第一步，獲得單例類的構造器。

第二步，把構造器設定為可訪問。

第三步，使用newInstance方法構造物件。

最後為了確認這兩個物件是否真的是不同的物件，我們使用equals方法進行比較。毫無疑問，比較結果是false。

用列舉實現單例模式：

public enum SingletonEnum {
    INSTANCE;
}複製程式碼

複製程式碼

讓我們來做一個實驗，仍然執行剛才的反射程式碼：

//獲得構造器
Constructor con = SingletonEnum.class.getDeclaredConstructor();
//設定為可訪問
con.setAccessible(true);
//構造兩個不同的物件
SingletonEnum singleton1 = (SingletonEnum)con.newInstance();
SingletonEnum singleton2 = (SingletonEnum)con.newInstance();
//驗證是否是不同物件
System.out.println(singleton1.equals(singleton2));複製程式碼

執行獲得構造器這一步的時候，丟擲瞭如下異常：

Exception in thread "main" java.lang.NoSuchMethodException: com.xiaohui.singleton.test.SingletonEnum.<init>()

at java.lang.Class.getConstructor0(Class.java:2892)

at java.lang.Class.getDeclaredConstructor(Class.java:2058)

at com.xiaohui.singleton.test.SingletonTest.main(SingletonTest.java:22)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:606)

at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)