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

單例模式第一版：

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;
}

class Resource{
}

public enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

使用列舉單例模式不僅能夠防止反射構造物件，而且可以保證執行緒安全，這種方式唯一的缺點就是並非使用懶載入，其單例物件是列舉類被載入的時候進行初始化的。

幾點補充：

1. volatile關鍵字不但可以防止指令重排，也可以保證執行緒訪問的變數值是主記憶體中的最新值。有關volatile的詳細原理，我在以後的漫畫中會專門講解。

2.使用列舉實現的單例模式，不但可以防止利用反射強行構建單例物件，而且可以在列舉類物件被反序列化的時候，保證反序列的返回結果是同一物件。

對於其他方式實現的單例模式，如果既想要做到可序列化，又想要反序列化為同一物件，則必須實現readResolve方法。