作爲對象的創建模式,單例模式確保某一個類只有一個實例,而且自行實例化並向整個系統提供這個實例。這個類稱爲單例類
單例模式的結構
單例模式的特點:
- 單例類只能有一個實例。
- 單例類必須自己創建自己的唯一實例。
- 單例類必須給所有其他對象提供這一實例。
餓漢式單例類
- public class EagerSingleton {
- private static EagerSingleton instance = new EagerSingleton();
- /**
- * 私有默認構造子
- */
- private EagerSingleton(){}
- /**
- * 靜態工廠方法
- */
- public static EagerSingleton getInstance(){
- return instance;
- }
- }
上面的例子中,在這個類被加載時,靜態變量instance會被初始化,此時類的私有構造子會被調用。這時候,單例類的唯一實例就被創建出來了。
餓漢式其實是一種比較形象的稱謂。既然餓,那麼在創建對象實例的時候就比較着急,餓了嘛,於是在裝載類的時候就創建對象實例。
- private static EagerSingleton instance = new EagerSingleton();
懶漢式單例類
- public class LazySingleton {
- private static LazySingleton instance = null;
- /**
- * 私有默認構造子
- */
- private LazySingleton(){}
- /**
- * 靜態工廠方法
- */
- public static synchronized LazySingleton getInstance(){
- if(instance == null){
- instance = new LazySingleton();
- }
- return instance;
- }
- }
上面的懶漢式單例類實現裏對靜態工廠方法使用了同步化,以處理多線程環境。
懶漢式其實是一種比較形象的稱謂。既然懶,那麼在創建對象實例的時候就不着急。會一直等到馬上要使用對象實例的時候纔會創建,懶人嘛,總是推脫不開的時候纔會真正去執行工作,因此在裝載對象的時候不創建對象實例。
- private static LazySingleton instance = null;
懶漢式是典型的時間換空間,就是每次獲取實例都會進行判斷,看是否需要創建實例,浪費判斷的時間。當然,如果一直沒有人使用的話,那就不會創建實例,則節約內存空間
由於懶漢式的實現是線程安全的,這樣會降低整個訪問的速度,而且每次都要判斷。那麼有沒有更好的方式實現呢?
雙重檢查加鎖
可以使用“雙重檢查加鎖”的方式來實現,就可以既實現線程安全,又能夠使性能不受很大的影響。那麼什麼是“雙重檢查加鎖”機制呢?
所謂“雙重檢查加鎖”機制,指的是:並不是每次進入getInstance方法都需要同步,而是先不同步,進入方法後,先檢查實例是否存在,如果不存在才進行下面的同步塊,這是第一重檢查,進入同步塊過後,再次檢查實例是否存在,如果不存在,就在同步的情況下創建一個實例,這是第二重檢查。這樣一來,就只需要同步一次了,從而減少了多次在同步情況下進行判斷所浪費的時間。
“雙重檢查加鎖”機制的實現會使用關鍵字volatile,它的意思是:被volatile修飾的變量的值,將不會被本地線程緩存,所有對該變量的讀寫都是直接操作共享內存,從而確保多個線程能正確的處理該變量。
注意:在java1.4及以前版本中,很多JVM對於volatile關鍵字的實現的問題,會導致“雙重檢查加鎖”的失敗,因此“雙重檢查加鎖”機制只只能用在java5及以上的版本。
- public class Singleton {
- private volatile static Singleton instance = null;
- private Singleton(){}
- public static Singleton getInstance(){
- //先檢查實例是否存在,如果不存在才進入下面的同步塊
- if(instance == null){
- //同步塊,線程安全的創建實例
- synchronized (Singleton.class) {
- //再次檢查實例是否存在,如果不存在才真正的創建實例
- if(instance == null){
- instance = new Singleton();
- }
- }
- }
- return instance;
- }
- }
這種實現方式既可以實現線程安全地創建實例,而又不會對性能造成太大的影響。它只是第一次創建實例的時候同步,以後就不需要同步了,從而加快了運行速度。
提示:由於volatile關鍵字可能會屏蔽掉虛擬機中一些必要的代碼優化,所以運行效率並不是很高。因此一般建議,沒有特別的需要,不要使用。也就是說,雖然可以使用“雙重檢查加鎖”機制來實現線程安全的單例,但並不建議大量採用,可以根據情況來選用。
根據上面的分析,常見的兩種單例實現方式都存在小小的缺陷,那麼有沒有一種方案,既能實現延遲加載,又能實現線程安全呢?
Lazy initialization holder class模式
這個模式綜合使用了Java的類級內部類和多線程缺省同步鎖的知識,很巧妙地同時實現了延遲加載和線程安全。
1.相應的基礎知識
- 什麼是類級內部類?
簡單點說,類級內部類指的是,有static修飾的成員式內部類。如果沒有static修飾的成員式內部類被稱爲對象級內部類。
類級內部類相當於其外部類的static成分,它的對象與外部類對象間不存在依賴關係,因此可直接創建。而對象級內部類的實例,是綁定在外部對象實例中的。
類級內部類中,可以定義靜態的方法。在靜態方法中只能夠引用外部類中的靜態成員方法或者成員變量。
類級內部類相當於其外部類的成員,只有在第一次被使用的時候才被會裝載。
- 多線程缺省同步鎖的知識
大家都知道,在多線程開發中,爲了解決併發問題,主要是通過使用synchronized來加互斥鎖進行同步控制。但是在某些情況中,JVM已經隱含地爲您執行了同步,這些情況下就不用自己再來進行同步控制了。這些情況包括:
1.由靜態初始化器(在靜態字段上或static{}塊中的初始化器)初始化數據時
2.訪問final字段時
3.在創建線程之前創建對象時
4.線程可以看見它將要處理的對象時
2.解決方案的思路
要想很簡單地實現線程安全,可以採用靜態初始化器的方式,它可以由JVM來保證線程的安全性。比如前面的餓漢式實現方式。但是這樣一來,不是會浪費一定的空間嗎?因爲這種實現方式,會在類裝載的時候就初始化對象,不管你需不需要。
如果現在有一種方法能夠讓類裝載的時候不去初始化對象,那不就解決問題了?一種可行的方式就是採用類級內部類,在這個類級內部類裏面去創建對象實例。這樣一來,只要不使用到這個類級內部類,那就不會創建對象實例,從而同時實現延遲加載和線程安全。
示例代碼如下:
- public class Singleton {
- private Singleton(){}
- /**
- * 類級的內部類,也就是靜態的成員式內部類,該內部類的實例與外部類的實例
- * 沒有綁定關係,而且只有被調用到時纔會裝載,從而實現了延遲加載。
- */
- private static class SingletonHolder{
- /**
- * 靜態初始化器,由JVM來保證線程安全
- */
- private static Singleton instance = new Singleton();
- }
- public static Singleton getInstance(){
- return SingletonHolder.instance;
- }
- }
當getInstance方法第一次被調用的時候,它第一次讀取SingletonHolder.instance,導致SingletonHolder類得到初始化;而這個類在裝載並被初始化的時候,會初始化它的靜態域,從而創建Singleton的實例,由於是靜態的域,因此只會在虛擬機裝載類的時候初始化一次,並由虛擬機來保證它的線程安全性。
這個模式的優勢在於,getInstance方法並沒有被同步,並且只是執行一個域的訪問,因此延遲初始化並沒有增加任何訪問成本。
單例和枚舉
按照《高效Java 第二版》中的說法:單元素的枚舉類型已經成爲實現Singleton的最佳方法。用枚舉來實現單例非常簡單,只需要編寫一個包含單個元素的枚舉類型即可。
- public enum Singleton {
- /**
- * 定義一個枚舉的元素,它就代表了Singleton的一個實例。
- */
- uniqueInstance;
- /**
- * 單例可以有自己的操作
- */
- public void singletonOperation(){
- //功能處理
- }
- }
使用枚舉來實現單實例控制會更加簡潔,而且無償地提供了序列化機制,並由JVM從根本上提供保障,絕對防止多次實例化,是更簡潔、高效、安全的實現單例的方式。