設計模式之單例模式詳解

• 2020 年 7 月 19 日
• 筆記

單例模式

認識單例模式

什麼是單例模式

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

比如Hibernate的SessionFactory，它充當數據存儲源的代理，並負責創建Session對象。SessionFactory並不是輕量級的，一般情況下，一個項目通常只需要一個SessionFactory就夠了，這時就會使用到單例模式。3.1.2 單例模式的八種方式
單例模式有八種方式：

1. 餓漢式（靜態常量）；
2. 餓漢式（靜態程式碼塊）；
3. 懶漢式（執行緒不安全）；
4. 懶漢式（執行緒安全，同步方法）；
5. 懶漢式（執行緒安全，同步程式碼塊）；
6. 雙重檢查；
7. 靜態內部類；
8. 枚舉

八種方式詳解

餓漢式（靜態常量）

程式碼演示：

public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//餓漢式（靜態常量）
class Singleton {
    //1、構造器私有化，外部不能new
    private Singleton() {

    }

    //2、本類內部創建對象實例
    private final static Singleton instance = new Singleton();

    //3、提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance() {
        return instance;
    }
}

優缺點說明：

• 優點：這種寫法比較簡單，就是在類裝載的時候就完成實例化，避免了執行緒同步問題；
• 缺點：在類裝載的時候就完成實例化，沒有達到懶載入的效果，如果從始至終從未使用過這個實例，則會造成記憶體的浪費；
• 這種方式基於classloder機制避免了多執行緒的同步問題，不過，instance在類裝載時就實例化，在單例模式中大多數都是調用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他靜態方法）導致類載入，這時候初始化instance就沒有達到懶載入的效果。
• 結論：這種單例模式可用，可能造成記憶體浪費。

餓漢式（靜態程式碼塊）

程式碼演示：

public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//餓漢式（靜態程式碼塊）
class Singleton {
    //1、構造器私有化，外部不能new
    private Singleton() {

    }

    //2、靜態程式碼塊
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    //3、提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance() {
        return instance;
    }
}

優缺點說明：

• 這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態程式碼塊中，也是在類裝載的時候，就執行靜態程式碼快中的程式碼，初始化類的實例。優缺點和上面是一樣的。
• 結論：這種單例模式可用，但是可能造成記憶體浪費。

懶漢式（執行緒不安全）

程式碼演示：

public class SingletonTest3 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//懶漢式（執行緒不安全）
class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

    //提供一個靜態的公有方法，當使用到該方法時，才去創建instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點說明：

• 起到了懶載入的效果，但是只能在單執行緒下使用；
• 如果在多執行緒下，一個執行緒進入了if(singleton==null)判斷語句塊，還未來得及往下執行，另一個執行緒也通過了這個判斷語句，這時便會產生多個實例。所以在多執行緒環境下不可使用這種方式。
• 結論：在實際開發中，不要使用這種方式。

懶漢式（執行緒安全，同步方法）

程式碼演示：

public class SingletonTest4 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//懶漢式（執行緒安全，同步方法）
class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

    //提供一個靜態的公有方法，加入同步處理的程式碼，解決執行緒安全問題
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點說明：

• 解決了執行緒安全問題；
• 效率太低了，每個執行緒在想獲得類的實例的時候，執行getInstance（）方法都要進行同步。而其實這個方法只執行一次實例化程式碼就夠了，後面的想獲得該類實例，直接return就行了。方法進行同步效率太低；
• 結論：在實際開發中，不推薦使用這種方式。

懶漢式（執行緒安全，同步程式碼塊）

程式碼演示：

public class SingletonTest5 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//懶漢式（執行緒安全，同步程式碼塊）
class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

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

說明：

• 看似執行緒安全，但不一定安全。
• 結論：不推薦使用。

雙重檢查

程式碼演示：

public class SingletonTest6 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//雙重檢查
class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

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

優缺點說明：

• Double-Check概念是多執行緒開發中常使用到的，如程式碼中所示，我們進行了兩次if(singleton==null)檢查，這樣就可以保證執行緒安全了。
• 這樣，實例化程式碼只用執行一次，後面再次訪問時，判斷if(singleton==null)，直接reeturn實例化對象，也避免反覆進行方法同步；
• 執行緒安全，延遲載入，效率較高；
• 結論：在實際開發中，推薦使用這種單例設計模式。

靜態內部類

程式碼演示：

public class SingletonTest7 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

//靜態內部類
class Singleton {

    private Singleton() {
    }

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

    //提供一個靜態的公有方法，直接返回對象
    public static synchronized Singleton getInstance() {
        return singleInstance.INSTANCE;
    }
}

優缺點說明：

• 靜態內部類方式在Singleton類被裝載時並不會立即實例化，而是在需要實例化時，調用getInstance方法，會裝載SingletonInstance類，從而完成Singleton的實例化；
• 類的靜態屬性只會在第一次載入類的時候初始化，所以在這裡，JVM幫助我們保證了執行緒的安全性，在類進行初始化時，別的執行緒是無法進入的；
• 優點：避免了執行緒不安全，利用靜態內部類特點實現延遲載入，效率高；
• 結論：推薦使用

枚舉

程式碼演示：

public class SingletonTest8 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        instance.sayOK();
    }
}

//使用枚舉，可以實現單例
enum Singleton {
    INSTANCE;//屬性

    public void sayOK() {
        System.out.println("ok");
    }
}

優缺點說明：

• 這藉助了JDK1.5中添加的枚舉來實現單例模式，不僅能避免多執行緒同步問題，而且還能防止反序列化重新創建新的對象；
• 結論：推薦使用

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

單例模式保證了系統記憶體中該類只存在一個對象，節省了系統資源，對於一些需要頻繁創建銷毀的對象，使用單例模式可以提高系統性能。

• 當想實例化一個單例類的時候，必須要記住使用相應的獲得對象的方法，而不是使用new；
• 單例模式使用場景：需要頻繁的進行創建和銷毀的對象、創建對象時耗時過多或耗費資源過多（即：重量級對象），但又經常用到的對象、工具類對象、頻繁訪問資料庫或文件的對象（比如數據源、session工廠等）。