[ Java ] 單例模式 的八種實現方式

來源：尚硅谷 Java 設計模式

單例設計模式，就是採取一定的方法保證在整個的軟件系統中，對某個類
只能存在一個對象實例，並且該類只提供一個取得其對象實例的方法（靜態方法）。

---

一、餓漢式（靜態常量）

• 優點：在類裝載的時候就完成實例化。避免了線程同步問題。

• 缺點：在類裝載的時候就完成實例化，沒有達到Lazy Loading的效果。如果從始至終從未使用過這個實例，則會造成內存的浪費

• 這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，在單例模式中大多數都是調用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式(或者其他的靜態方法)導致類裝載，這時候初始化instance就沒有達到lazy loading的效果

• 代碼實現

public class Test {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton{
    // 構造器私有化，外部不能 new
    private Singleton(){

    }
    // 本類內部創建對象實例
    private final static Singleton instance = new Singleton();
    // 公有靜態方法，返回對象實例
    public static Singleton getInstance(){
        return instance;
    }
}

二、餓漢式（靜態代碼塊）

• 這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態代碼塊中，也是在類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實例。優缺點和上面是一樣的。
• 代碼實現

class Singleton{
    // 構造器私有化，外部不能 new
    private Singleton(){}
    // 本類內部聲明對象實例
    private final static Singleton instance;
    // 在靜態代碼塊中創建單例對象
    static {
        instance = new Singleton();
    }
    // 公有靜態方法，返回對象實例
    public static Singleton getInstance(){
        return instance;
    }
}

三、懶漢式（線程不安全）

• 起到了Lazy Loading的效果，但是隻能在單線程下使用。

• 如果在多線程下，一個線程進入了if (singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例。所以在多線程環境下不可使用這種方式

• 結論：在實際開發中，不能使用這種方式.

• 代碼實現

class Singleton{
    // 本類內部聲明對象實例
    private static Singleton instance;

    // 構造器私有化，外部不能 new
    private Singleton(){}

    // 公有靜態方法，返回對象實例
    // 當使用該方法時，纔去創建 instance
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

四、懶漢式（線程安全，同步方法）

• 解決了線程不安全問題

• 效率太低，每個線程在想獲得類的實例時候，執行getInstance()方法都要進行同步。而其實這個方法只執行一次實例化代碼就夠了，後面的想獲得該類實例，.直接return就行了。方法進行同步效率太低

• 結論：在實際開發中，不推薦使用這種方式

• 代碼實現

class Singleton{
    // 本類內部聲明對象實例
    private static Singleton instance;

    // 構造器私有化，外部不能 new
    private Singleton(){}

    // 公有靜態方法，加入同步處理的代碼，解決線程安全問題
    // 當使用該方法時，纔去創建 instance
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

五、懶漢式

• 這種方式，本意是想對第四種實現方式的改進，因爲前面同步方法效率太低，改爲同步產生實例化的的代碼塊
• 但是這種同步並不能起到線程同步的作用。跟第3種實現方式遇到的情形一致，假如一個線程進入了if (singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例
• 結論：在實際開發中，不能使用這種方式
• 代碼實現

class Singleton{
    // 本類內部聲明對象實例
    private static Singleton instance;

    // 構造器私有化，外部不能 new
    private Singleton(){}

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

六、雙重檢查

• Double-Check概念 是多線程開發中常使用到的，如代碼中所示，我們進行了兩次if (singleton == null)檢查，這樣就可以保證線程安全了。

• 這樣，實例化代碼只用執行一-次，後面再次訪問時，判斷if (singleton == null)，直接return實例化對象，也避免的反覆進行方法同步.

• 線程安全，延遲加載，效率較高

• 在實際開發中，推薦使用這種方式實現單例設計模式

• 代碼實現

class Singleton{
    // 本類內部聲明對象實例
    private static volatile Singleton instance;

    // 構造器私有化，外部不能 new
    private Singleton(){}

    // 靜態公有方法，加入雙重檢查代碼
    // 解決線程安全問題，同時解決懶加載問題
    public static synchronized Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

七、靜態內部類

• 這種方式採用了類裝載的機制來保證初始化實例時只有-一個線程。

• 靜態內部類萬式在Singleton類被裝載時並不會立即實例化，而是在需要實例化時，調用getInstance方法， 纔會裝載SingletonInstance類，從而完成Singleton的實例化。

• 類的靜態屬性只會在第-次加載類的時候初始化，所以在這裏，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的。

• 優點：避免了線程不安全，利用靜態內部類特點實現延遲加載，效率高

• 結論：推薦使用.

• 代碼實現

class Singleton {
    // 構造器私有化，外部不能 new
    private Singleton() {
    }

    // 靜態內部類，該類中有一個靜態屬性
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
    /**
     * 說明：
     *  JVM 在裝載類時，是線程安全的
     *  在裝載 Singleton 時，不會同時裝載 SingletonInstance
     */
}

八、枚舉

• 這藉助JDK1.5中添加的枚舉來實現單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重 新創建新的對象。
• 這種方式是《Effectivt Java》作者 Josh Bloch 提倡的方式
• 推薦使用
• 代碼實現

public class Test {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
        singleton.say();
    }
}

enum Singleton{
    INSTANCE;
    public void say(){
        System.out.println("hello");
    }
}

單例模式注意事項和細節說明:

• 單例模式保證了系統內存中該類只存在一個對象，節省了系統資源，對於一些需要頻繁創建銷燬的對象，使用單例模式可以提高系統性能。
• 當想實例化一個單例類的時候，必須要記住使用相應的獲取對象的方法，而不是使用new
• 單例模式使用的場景：需要頻繁的進行創建和銷燬的對象、創建對象時耗時過多或耗費資源過多(即:重量級對象)，但又經常用到的對象、工具類對象、頻繁訪問數據庫或文件的對象（比如數據源,session工廠等）

來源：尚硅谷 Java 設計模式

---