《JAVA與設計模式》之單例模式

原文連線：http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html

在閻巨集博士的《JAVA與模式》一書中開頭是這樣描述單例模式的：
作為物件的建立模式，單例模式確保某一個類只有一個例項，而且自行例項化並向整個系統提供這個例項。這個類稱為單例類。

單例模式的特點：

• 單例類只能有一個例項。
• 單例類必須自己建立自己的唯一例項。
• 單例類必須給所有其他物件提供這一例項。

餓漢式單例類

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已經隱含地為您執行了同步，這些情況下就不用自己再來進行同步控制了。這些情況包括：

由靜態初始化器（在靜態欄位上或static{}塊中的初始化器）初始化資料時
訪問final欄位時
在建立執行緒之前建立物件時
執行緒可以看見它將要處理的物件時

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從根本上提供保障，絕對防止多次例項化，是更簡潔、高效、安全的實現單例的方式。