3、單例模式

單例模式

前言

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬於建立型模式，它提供了一種建立對象的最佳方式。

這種模式涉及到一個單一的類，該類負責建立本身的對象，同時確保只有單個對象被建立。這個類提供了一種訪問其惟一的對象的方式，能夠直接訪問，不須要實例化該類的對象。

注意：

• 一、單例類只能有一個實例。
• 二、單例類必須本身建立本身的惟一實例。
• 三、單例類必須給全部其餘對象提供這一實例。

單例模式的幾種實現方式

【1】懶漢式(線程不安全)

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  

    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

這種方式是最基本的實現方式，這種實現最大的問題就是不支持多線程。由於沒有加鎖 synchronized，因此嚴格意義上它並不算單例模式。
這種方式 lazy loading 很明顯，不要求線程安全，在多線程不能正常工做。

【2】懶漢式(線程安全)

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

這種方式的好處是寫起來簡單，且絕對線程安全；壞處是併發性能極差，事實上徹底退化到了串行。單例只須要初始化一次，但就算初始化之後，synchronized的鎖也沒法避開，從而getInstance()徹底變成了串行操做。性能不敏感的場景建議使用。

【3】餓漢式

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

這種方式比較經常使用，但容易產生垃圾對象，即類加載時初始化單例，之後訪問時直接返回便可。

它基於類加載機制避免了多線程的同步問題，可是沒有達到懶加載的效果

【4】雙重校驗鎖(DCL)

public class Singleton {
    private static Singleton instance;
    
    public int f1 = 1;   // 觸發部分初始化問題
    public int f2 = 2;
        
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (instance == null) { // 當instance不爲null時，可能指向一個「被部分初始化的對象」
            synchronized (Singleton.class) {
                if ( instance == null ) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

這種方式看起來彷佛已經達到了理想的效果：懶加載+線程安全。可是DCL仍然是線程不安全的，因爲指令重排序，會遇到」部分初始化問題」。

問題出在這行簡單的賦值語句：

instance = new Singleton();

它並非一個原子操做。事實上，它能夠」抽象「爲下面幾條JVM指令：

memory = allocate();    //1：分配對象的內存空間
initInstance(memory);   //2：初始化對象（對f一、f2初始化）
instance = memory;      //3：設置instance指向剛分配的內存地址

上面操做2依賴於操做1，可是操做3並不依賴於操做2，因此JVM能夠以「優化」爲目的對它們進行重排序，通過重排序後以下：

memory = allocate();    //1：分配對象的內存空間
instance = memory;      //3：設置instance指向剛分配的內存地址（此時對象還未初始化）
ctorInstance(memory);   //2：初始化對象

能夠看到指令重排以後，操做 3 排在了操做 2 以前，即引用instance指向內存memory時，這段嶄新的內存尚未初始化——即，引用instance指向了一個」被部分初始化的對象」。此時，若是另外一個線程調用getInstance方法，因爲instance已經指向了一塊內存空間，從而if條件判爲false，方法返回instance引用，用戶獲得了沒有完成初始化的「半個」單例。
解決這個該問題，只須要將instance聲明爲volatile變量

【5】登記式/靜態內部類

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

這種方式能達到雙檢鎖方式同樣的功效，但實現更簡單。對靜態域使用延遲初始化，應使用這種方式而不是雙檢鎖方式。這種方式只適用於靜態域的狀況，雙檢鎖方式可在實例域須要延遲初始化時使用。
這種方式一樣利用了類加載機制來保證初始化 instance 時只有一個線程，它跟第餓漢式種方式不一樣的是：餓漢式方式只要 Singleton 類被裝載了，那麼 instance 就會被實例化（沒有達到 lazy loading 效果），而這種方式是 Singleton 類被裝載了，instance 不必定被初始化。由於 SingletonHolder 類沒有被主動使用，只有經過顯式調用 getInstance 方法時，纔會顯式裝載 SingletonHolder 類，從而實例化 instance。

【6】枚舉

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

這種實現方式尚未被普遍採用，但這是實現單例模式的最佳方法。它更簡潔，自動支持序列化機制，絕對防止屢次實例化。