在別人的程式碼裡，看到用了一種很奇葩的方式，實現的單例模式，後來搜尋了下這樣實現的原因，才知道這是一個叫Initialization Demand Holder (IoDH)的技術，轉了兩篇，和大家分享下。

原文地址1

原文地址2

3.4 餓漢式單例與懶漢式單例的討論

      Sunny公 司開發人員使用單例模式實現了負載均衡器的設計，但是在實際使用中出現了一個非常嚴重的問題，當負載均衡器在啟動過程中使用者再次啟動該負載均衡器時，系統 無任何異常，但當客戶端提交請求時出現請求分發失敗，通過仔細分析發現原來系統中還是存在多個負載均衡器物件，導致分發時目標伺服器不一致，從而產生衝 突。為什麼會這樣呢？Sunny

      現在我們對負載均衡器的實現程式碼進行再次分析，當第一次呼叫getLoadBalancer()方法建立並啟動負載均衡器時，instance物件為null值，因此係統將執行程式碼instance= new LoadBalancer()，在此過程中，由於要對LoadBalancer進行大量初始化工作，需要一段時間來建立LoadBalancer物件。而在此時，如果再一次呼叫getLoadBalancer()方法（通常發生在多執行緒環境中），由於instance尚未建立成功，仍為null值，判斷條件(instance== null)為真值，因此程式碼instance= new LoadBalancer()

      如何解決該問題？我們至少有兩種解決方案，在正式介紹這兩種解決方案之前，先介紹一下單例類的兩種不同實現方式，餓漢式單例類和懶漢式單例類。

1.餓漢式單例類

      餓漢式單例類是實現起來最簡單的單例類，餓漢式單例類結構圖如圖3-4所示：

1. class EagerSingleton {   
2.     privatestaticfinal EagerSingleton instance = 
   new EagerSingleton();   
3.     private EagerSingleton() { }   
4.     publicstatic EagerSingleton getInstance() {  
5.         return instance;   
6.     }     
7. }  

2.懶漢式單例類與執行緒鎖定

      除了餓漢式單例，還有一種經典的懶漢式單例，也就是前面的負載均衡器LoadBalancer類的實現方式。懶漢式單例類結構圖如圖3-5所示：

1. class LazySingleton {   
2.     privatestatic LazySingleton instance = null;   
3.     private LazySingleton() { }   
4.     synchronizedpublicstatic LazySingleton getInstance() {   
5.         if (instance == null) {  
6.             instance = new LazySingleton();   
7.         }  
8.         return instance;   
9.     }  
10. }  

1. publicstatic LazySingleton getInstance() {   
2.     if (instance == null) {  
3.         synchronized (LazySingleton.class) {  
4.             instance = new LazySingleton();   
5.         }  
6.     }  
7.     return instance;   
8. }  

      假如在某一瞬間執行緒A和執行緒B都在呼叫getInstance()方法，此時instance物件為null值，均能通過instance == null的判斷。由於實現了synchronized加鎖機制，執行緒A進入synchronized鎖定的程式碼中執行例項建立程式碼，執行緒B處於排隊等待狀態，必須等待執行緒A執行完畢後才可以進入synchronized鎖定程式碼。但當A執行完畢時，執行緒B並不知道例項已經建立，將繼續建立新的例項，導致產生多個單例物件，違背單例模式的設計思想，因此需要進行進一步改進，在synchronized中再進行一次(instance == null)判斷，這種方式稱為雙重檢查鎖定(Double-Check Locking)。使用雙重檢查鎖定實現的懶漢式單例類完整程式碼如下所示：

1. class LazySingleton {   
2.     privatevolatilestatic LazySingleton instance = null;   
3.     private LazySingleton() { }   
4.     publicstatic LazySingleton getInstance() {   
5.         //第一重判斷
6.         if (instance == null) {  
7.             //鎖定程式碼塊
8.             synchronized (LazySingleton.class) {  
9.                 //第二重判斷
10.                 if (instance == null) {  
11.                     instance = new LazySingleton(); //建立單例例項
12.                 }  
13.             }  
14.         }  
15.         return instance;   
16.     }  
17. }  

       需要注意的是，如果使用雙重檢查鎖定來實現懶漢式單例類，需要在靜態成員變數instance之前增加修飾符volatile，被volatile修飾的成員變數可以確保多個執行緒都能夠正確處理，且該程式碼只能在JDK 1.5及以上版本中才能正確執行。由於volatile關鍵字會遮蔽Java虛擬機器所做的一些程式碼優化，可能會導致系統執行效率降低，因此即使使用雙重檢查鎖定來實現單例模式也不是一種完美的實現方式。

3.餓漢式單例類與懶漢式單例類比較

      餓漢式單例類在類被載入時就將自己例項化，它的優點在於無須考慮多執行緒訪問問題，可以確保例項的唯一性；從呼叫速度和反應時間角度來講，由於單例物件一開 始就得以建立，因此要優於懶漢式單例。但是無論系統在執行時是否需要使用該單例物件，由於在類載入時該物件就需要建立，因此從資源利用效率角度來講，餓漢 式單例不及懶漢式單例，而且在系統載入時由於需要建立餓漢式單例物件，載入時間可能會比較長。

      懶漢式單例類在第一次使用時建立，無須一直佔用系統資源，實現了延遲載入，但是必須處理好多個執行緒同時訪問的問題，特別是當單例類作為資源控制器，在例項 化時必然涉及資源初始化，而資源初始化很有可能耗費大量時間，這意味著出現多執行緒同時首次引用此類的機率變得較大，需要通過雙重檢查鎖定等機制進行控制， 這將導致系統性能受到一定影響。

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

3.5 一種更好的單例實現方法

餓漢式單例類不能實現延遲載入，不管將來用不用始終佔據記憶體；懶漢式單例類執行緒安全控制煩瑣，而且效能受影響。可見，無論是餓漢式單例還是懶漢式單例都存在這樣那樣的問題，有沒有一種方法，能夠將兩種單例的缺點都克服，而將兩者的優點合二為一呢？答案是：Yes！下面我們來學習這種更好的被稱之為Initialization Demand Holder (IoDH)的技術。

      在IoDH中，我們在單例類中增加一個靜態(static)內部類，在該內部類中建立單例物件，再將該單例物件通過getInstance()方法返回給外部使用，實現程式碼如下所示：

1. //Initialization on Demand Holder
2. class Singleton {  
3.     private Singleton() {  
4.     }  
5.     privatestaticclass HolderClass {  
6.             privatefinalstatic Singleton instance = new Singleton();  
7.     }  
8.     publicstatic Singleton getInstance() {  
9.         return HolderClass.instance;  
10.     }  
11.     publicstaticvoid main(String args[]) {  
12.         Singleton s1, s2;   
13.             s1 = Singleton.getInstance();  
14.         s2 = Singleton.getInstance();  
15.         System.out.println(s1==s2);  
16.     }  
17. }  

       編譯並執行上述程式碼，執行結果為：true，即建立的單例物件s1和s2為同一物件。由於靜態單例物件沒有作為Singleton的成員變數直接例項化，因此類載入時不會例項化Singleton，第一次呼叫getInstance()時將載入內部類HolderClass，在該內部類中定義了一個static型別的變數instance，此時會首先初始化這個成員變數，由Java虛擬機器來保證其執行緒安全性，確保該成員變數只能初始化一次。由於getInstance()方法沒有任何執行緒鎖定，因此其效能不會造成任何影響。

      通過使用IoDH，我們既可以實現延遲載入，又可以保證執行緒安全，不影響系統性能，不失為一種最好的Java語言單例模式實現方式（其缺點是與程式語言本身的特性相關，很多面向物件語言不支援IoDH）。

至此，三種單例類的實現方式我們均已學習完畢，它們分別是餓漢式單例、懶漢式單例以及IoDH。