1. 程式人生 > >singleton模式四種執行緒安全的實現

singleton模式四種執行緒安全的實現

1.描述:

    Singleton(單例)是設計模式的一種,為了保證一個類僅有一個例項,並提供一個訪問它的全域性訪問點。

2.主要特點:

    1)單例類確保自己只有一個例項(建構函式私有:不被外部例項化,也不被繼承)。

    2)單例類必須自己建立自己的例項。

    3)單例類必須為其他物件提供唯一的例項。

3.單例模式的應用:

    資源管理器,回收站,印表機資源,執行緒池,快取,配置資訊類,管理類,控制類,門面類,代理類通常被設計為單例類

    如果程式有多個類載入器又同時使用單例模式就有可能多個單例並存就要找相應解決方法了

4.實現方法:

如果應用程式總是建立並使用單例例項或在建立和執行時開銷不大。

1).Eager initialization 餓漢式單例類(依賴jvm在載入類時建立唯一單例例項)

  1. publicclass EagerSingleton {    
  2.         // jvm保證在任何執行緒訪問uniqueInstance靜態變數之前一定先建立了此例項  
  3.         privatestatic EagerSingleton uniqueInstance = new EagerSingleton();    
  4.         // 私有的預設構造子,保證外界無法直接例項化  
  5.         private EagerSingleton() {    
  6.         }    
  7.         // 提供全域性訪問點獲取唯一的例項  
  8.         publicstatic EagerSingleton getInstance() {    
  9.                 return uniqueInstance;    
  10.         }    
  11. }  
如果開銷比較大,希望用到時才建立就要考慮延遲例項化,或者Singleton的初始化需要某些外部資源(比如網路或儲存裝置),就要用後面的方法了.

2)Lazy initialization 懶漢式單例類

  1. publicclass LazySingleton {    
  2.         privatestatic
     LazySingleton uniqueInstance;    
  3.         private LazySingleton() {    
  4.         }    
  5.         publicstaticsynchronized LazySingleton getInstance() {    
  6.                 if (uniqueInstance == null)    
  7.                         uniqueInstance = new LazySingleton();    
  8.                 return uniqueInstance;    
  9.         }    
  10. }   
同步一個方法可能造成程式執行效率下降100倍,完全沒有必要每次呼叫getInstance都加鎖,事實上我們只想保證一次初始化成功,其餘的快速返回而已,如果在getInstance頻繁使用的地方就要考慮重新優化了.

3)"雙檢鎖"(Double-Checked Lock)儘量將"加鎖"推遲,只在需要時"加鎖"(僅適用於Java 5.0 以上版本,volatile保證原子操作) 
happens-before:"什麼什麼一定在什麼什麼之前執行",也就是保證順序性.
現在的CPU有亂序執行的能力(也就是指令會亂序或並行執行,可以不按我們寫程式碼的順序執行記憶體的存取過程),並且多個CPU之間的快取也不保證實時同步,只有上面的happens-before所規定的情況下才保證順序性.

JVM能夠根據CPU的特性(CPU的多級快取系統、多核處理器等)適當的重新排序機器指令,使機器指令更符合CPU的執行特點,最大限度的發揮機器的效能.

如果沒有volatile修飾符則可能出現一個執行緒t1的B操作和另一執行緒t2的C操作之間對instance的讀寫沒有happens-before,可能會造成的現象是t1的B操作還沒有完全構造成功,但t2的C已經看到instance為非空,這樣t2就直接返回了未完全構造的instance的引用,t2想對instance進行操作就會出問題.

    volatile 的功能:
1. 避免編譯器將變數快取在暫存器裡  
2. 避免編譯器調整程式碼執行的順序

優化器在用到這個變數時必須每次都小心地重新讀取這個變數的值,而不是使用儲存在暫存器裡的備份。

  1. publicclass DoubleCheckedLockingSingleton {    
  2.         // java中使用雙重檢查鎖定機制,由於Java編譯器和JIT的優化的原因系統無法保證我們期望的執行次序。  
  3.         // 在java5.0修改了記憶體模型,使用volatile宣告的變數可以強制遮蔽編譯器和JIT的優化工作  
  4.         privatevolatilestatic DoubleCheckedLockingSingleton uniqueInstance;    
  5.         private DoubleCheckedLockingSingleton() {    
  6.         }    
  7.         publicstatic DoubleCheckedLockingSingleton getInstance() {    
  8.                 if (uniqueInstance == null) {    
  9.                         synchronized (DoubleCheckedLockingSingleton.class) {    
  10.                                 if (uniqueInstance == null) {    
  11.                                         uniqueInstance = new DoubleCheckedLockingSingleton();    
  12.                                 }    
  13.                         }    
  14.                 }    
  15.                 return uniqueInstance;    
  16.         }    
  17. }    
4)Lazy initialization holder class 滿足所有 Double-Checked Locking 滿足的條件,並且沒有顯示的同步操作
  1. publicclass LazyInitHolderSingleton {    
  2.         private LazyInitHolderSingleton() {    
  3.         }    
  4.         privatestaticclass SingletonHolder {    
  5.                 privatestaticfinal LazyInitHolderSingleton INSTANCE = new LazyInitHolderSingleton();    
  6.         }    
  7.         publicstatic LazyInitHolderSingleton getInstance() {    
  8.                 return SingletonHolder.INSTANCE;    
  9.         }    
  10. }    
根據jvm規範,當某物件第一次呼叫LazyInitHolderSingleton.getInstance()時,LazyInitHolderSingleton類被首次主動使用,jvm對其進行初始化(此時並不會呼叫LazyInitHolderSingleton()構造方法),然後LazyInitHolderSingleton呼叫getInstance()方法,該方法中,又首次主動使用了SingletonHolder類,所以要對SingletonHolder類進行初始化,初始化中,INSTANCE常量被賦值時才呼叫了 LazyInitHolderSingleton的構造方法LazyInitHolderSingleton(),完成了例項化並返回該例項。 當再有物件(也許是在別的執行緒中)再次呼叫LazyInitHolderSingleton.getInstance()時,因為已經初始化過了,不會再進行初始化步驟,所以直接返回INSTANCE常量即同一個LazyInitHolderSingleton例項。