常見的幾種單例模式

時間 2019-11-25

標籤常見的幾種模式简体版

原文原文鏈接

　　單例模式：是一種經常使用的軟件設計模式，在它的核心結構中值包含一個被稱爲單例的特殊類。一個類只有一個實例，即一個類只有一個對象實例。html

　　對於系統中的某些類來講，只有一個實例很重要，例如，一個系統中能夠存在多個打印任務，可是隻能有一個正在工做的任務；售票時，一共有100張票，可有有多個窗口同時售票，但須要保證不要超售（這裏的票數餘量就是單例，售票涉及到多線程）。若是不是用機制對窗口對象進行惟一化將彈出多個窗口，若是這些窗口顯示的都是相同的內容，重複建立就會浪費資源。前端

　　應用場景（來源：《大話設計模式》）：java

　　　　需求：在前端建立工具箱窗口，工具箱要麼不出現，出現也只出現一個設計模式

　　　　遇到問題：每次點擊菜單都會重複建立「工具箱」窗口。安全

　　　　解決方案一：使用if語句，在每次建立對象的時候首先進行判斷是否爲null，若是爲null再建立對象。多線程

　　　　需求：若是在5個地方須要實例出工具箱窗體工具

　　　　遇到問題：這個小bug須要改動5個地方，而且代碼重複，代碼利用率低spa

　　　　解決方案二：利用單例模式，保證一個類只有一個實例，並提供一個訪問它的全局訪問點。線程

　　經過如下幾種方式，咱們會發現，全部的單例模式都是使用靜態方法進行建立的，因此單例對象在內存中靜態共享區中存儲。（可參考：https://zhidao.baidu.com/question/2206072272164938188.html）設計

　　 單例模式能夠分爲懶漢式和餓漢式：

　　　　懶漢式單例模式：在類加載時不初始化。

　　　　餓漢式單例模式：在類加載時就完成了初始化，因此類加載比較慢，但獲取對象的速度快。

　　第一種（懶漢，線程不安全）:

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

這種寫法lazy loading很明顯，可是致命的是在多線程不能正常工做。　

第二種（懶漢，線程安全）：

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

這種寫法在getInstance()方法中加入了synchronized鎖。可以在多線程中很好的工做，並且看起來它也具有很好的lazy loading，可是效率很低（由於鎖），而且大多數狀況下不須要同步。

第三種（餓漢）：

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

這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，這時候初始化instance顯然沒有達到lazy loading的效果。

　 第四種（餓漢，變種）：

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

表面上看起來差異挺大，其實更第三種方式差很少，都是在類初始化即實例化instance

第五種（靜態內部類）：

public class SingletonDemo5 {
    private static class SingletonHolder{
        private static final SingletonDemo5 instance = new SingletonDemo5();
    }
    private SingletonDemo5(){}
    public static final SingletonDemo5 getInsatance(){
        return SingletonHolder.instance;
    }
}

這種方式一樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不一樣的是（很細微的差異）：第三種和第四種方式是隻要Singleton類被裝載了，那麼instance就會被實例化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不必定被初始化。由於SingletonHolder類沒有被主動使用，只有顯示經過調用getInstance方法時，纔會顯示裝載SingletonHolder類，從而實例化instance。想象一下，若是實例化instance很消耗資源，我想讓他延遲加載，另一方面，我不但願在Singleton類加載時就實例化，由於我不能確保Singleton類還可能在其餘的地方被主動使用從而被加載，那麼這個時候實例化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方法就顯得更合理。

第六種（枚舉）：

public enum SingletonDemo6 {
    instance;
    public void whateverMethod(){
    }
}

這種方式是Effective Java做者Josh Bloch 提倡的方式，它不只能避免多線程同步問題，並且還能防止反序列化從新建立新的對象，可謂是很堅強的壁壘啊，不過，我的認爲因爲1.5中才加入enum特性，用這種方式寫難免讓人感受生疏，在實際工做中，我也不多看見有人這麼寫過。

第七種（雙重校驗鎖）：

public class SingletonDemo7 {
    private volatile static SingletonDemo7 singletonDemo7;
    private SingletonDemo7(){}
    public static SingletonDemo7 getSingletonDemo7(){
        if (singletonDemo7 == null) {
            synchronized (SingletonDemo7.class) {
                if (singletonDemo7 == null) {
                    singletonDemo7 = new SingletonDemo7();
                }
            }
        }
        return singletonDemo7;
    }
}