單例模式的七種寫法,你都知道嗎?

三分惡發表於2021-09-13

大家好,我是三乙己。考上大家一考:"單例模式的單例,怎樣寫的?"

"不就是構造方法私有化麼?"

”對呀對呀!……單例模式有七種寫法,你知道麼?“


言歸正傳……

單例模式(Singleton Pattern)可以說是最簡單的設計模式了。

用一個成語來形容單例模式——“天無二日,國無二主”。

你滴大王,無限猖狂

什麼意思呢?就是當前程式確保一個類全域性只有一個例項。

那單例模式有什麼好處呢?[1]

  • 單例模式在記憶體中只有一個例項,減少了記憶體開支
  • 單例模式只生成一個例項,所以減少了系統的效能開銷
  • 單例模式可以避免對資源的多重佔用
  • 單例模式可以在系統設定全域性的訪問點

那單例模式是銀彈嗎?它有沒有什麼缺點?

  • 單例模式一般沒有介面,擴充套件很困難
  • 單例模式不利於測試
  • 單例模式與單一職責原則有衝突

那什麼情況下要用單例模式呢?

  • 要求生成唯一序列號的環境
  • 在整個專案中需要一個共享訪問點或共享資料
  • 建立一個物件需要消耗的資源過多
  • 需要定義大量的靜態常量和靜態方法(如工具類)的環境

接下來,進入今天的主題,我們來看看單例模式的七種寫法!

1、餓漢式(執行緒安全)⭐

public class Singleton_1 {

    private static Singleton_1 instance=new Singleton_1();

    private Singleton_1() {
    }

    public static Singleton_1 getInstance() {
        return instance;
    }

}

餓漢式,就像它的名字,飢不擇食,定義的時候直接初始化。

因為instance是個靜態變數,所以它會在類載入的時候完成例項化,不存線上程安全的問題。

這種方式不是懶載入,不管我們的程式會不會用到,它都會在程式啟動之初進行初始化。

所以我們就有了下一種方式?

2、懶漢式(執行緒不安全)⭐

public class Singleton_2 {

    private static Singleton_2 instance;

    private Singleton_2() {
    }

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

}

懶漢式 是什麼呢?只有用到的時候才會載入,這就實現了我們心心念的懶載入。

但是!

它又引入了新的問題?什麼問題呢?執行緒安全問題。

懶漢式執行緒不安全

圖片也很清楚,多執行緒的情況下,可能存在這樣的問題:

一個執行緒判斷instance==null,開始初始化物件;

還沒來得及初始化物件時候,另一個執行緒訪問,判斷instance==null,也建立物件。

最後的結果,就是例項化了兩個Singleton物件。

這不符合我們單例的要求啊?怎麼辦呢?

3、懶漢式(加鎖)

public class Singleton_3 {

    private static Singleton_3 instance;

    private Singleton_3() {
    }

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

最直接的辦法,直接上鎖唄!

但是這種把鎖直接方法上的辦法,所有的訪問都需要獲取鎖,導致了資源的浪費。

那怎麼辦呢?

4、懶漢式(雙重校驗鎖)⭐

public class Singleton_4 {
    //volatile修飾,防止指令重排
    private static volatile Singleton_4 instance;

    private Singleton_4() {
    }

    public static Singleton_4 getInstance() {
        //第一重校驗,檢查例項是否存在
        if (instance == null) {
            //同步塊
            synchronized (Singleton_4.class) {
                //第二重校驗,檢查例項是否存在,如果不存在才真正建立例項
                if (instance == null) {
                    instance = new Singleton_4();
                }
            }
        }
        return instance;
    }

}

這是比較推薦的一種,雙重校驗鎖。

它的進步在哪裡呢?

我們把synchronized加在了方法的內部,一般的訪問是不加鎖的,只有在instance==null的時候才加鎖。

同時我們來看一下一些關鍵問題。

  • 首先我們看第一個問題,為什麼要雙重校驗?

大家想一下,如果不雙重校驗。

如果兩個執行緒一起呼叫getInstance方法,並且都通過了第一次的判斷instance==null,那麼第一個執行緒獲取了鎖,然後例項化了instance,然後釋放了鎖,然後第二個執行緒得到了執行緒,然後馬上也例項化了instance。這就不符合我們的單例要求了。

接著我們來看第二個問題,為什麼要用volatile 修飾 instance?

我們可能知道答案是防止指令重排。

那這個重排指的是哪?指的是instance = new Singleton(),我們感覺是一步操作的例項化物件,實際上對於JVM指令,是分為三步的:

  1. 分配記憶體空間
  2. 初始化物件
  3. 將物件指向剛分配的記憶體空間

有些編譯器為為了效能優化,可能會把第二步和第三步進行重排序,順序就成了:

  1. 分配記憶體空間
  2. 將物件指向剛分配的記憶體空間
  3. 初始化物件

指令重排

所以呢,如果不使用volatile防止指令重排可能會發生什麼情況呢?

訪問到未初始化物件

在這種情況下,T7時刻執行緒B對instance的訪問,訪問的是一個初始化未完成的物件。

所以需要在instance前加入關鍵字volatile

  • 使用了volatile關鍵字後,可以保證有序性,指令重排序被禁止;
  • volatile還可以保證可見性,Java記憶體模型會確保所有執行緒看到的變數值是一致的。

5、單例模式(靜態內部類)

public class Singleton_5 {

    private Singleton_5() {
    }

    private static class InnerSingleton {
        private static final Singleton_5 instance = new Singleton_5();
    }

    public static Singleton_5 getInstance() {
        return InnerSingleton.instance;
    }
}

靜態內部類是更進一步的寫法,不僅能實現懶載入、執行緒安全,而且JVM還保持了指令優化的能力。

Singleton類被裝載時並不會立即例項化,而是在需要例項化時,呼叫getInstance方法,才會載入靜態內部類InnerSingleton類,從而完成Singleton的例項化。

類的靜態屬性只會在第一次載入類的時候初始化,同時類載入的過程又是執行緒互斥的,JVM幫助我們保證了執行緒安全。

6、單例模式(CAS)

public class Singleton_6 {

    private static final AtomicReference<Singleton_6> INSTANCE = new AtomicReference<Singleton_6>();

    private Singleton_6() {
    }

    public static final Singleton_6 getInstance() {
        //等待
        while (true) {
            Singleton_6 instance = INSTANCE.get();
            if (null == instance) {
                INSTANCE.compareAndSet(null, new Singleton_6());
            }
            return INSTANCE.get();
        }
    }
}

這種CAS式的單例模式算是懶漢式直接加鎖的一個變種,sychronized是一種悲觀鎖,而CAS是樂觀鎖,相比較,更輕量級。

當然,這種寫法也比較罕見,CAS存在忙等的問題,可能會造成CPU資源的浪費。

7、單例模式(列舉)

public enum Singleton_7 {

    //定義一個列舉,代表了Singleton的一個例項
    INSTANCE;
    public void anyMethod(){
        System.out.println("do any thing");
    }
}

呼叫方式:

    @Test
    void anyMethod() {
        Singleton_7.INSTANCE.anyMethod();
    }

《Effective Java》作者推薦的一種方式,非常簡練。

但是這種寫法解決了最主要的問題:執行緒安全、⾃由串⾏化、單⼀例項。

總結

從使用的角度來講,如果不需要懶載入的話,直接餓漢式就行了;如果需要懶載入,可以考慮靜態內部類,或者嘗試一下列舉的方式。

從面試的角度,懶漢式、餓漢式、雙重校驗鎖餓漢式,這三種是重點。雙重校驗鎖方式一定要知道指令重排是在哪,會導致什麼問題。


簡單的事情重複做,重複的事情認真做,認真的事情有創造性地做。

我是三分惡,一個努力學習中的程式設計師。

點贊關注不迷路,我們們下期見!



參考:

[1]. 《設計模式之禪》

[2]. 《重學設計模式》

[3]. 設計模式系列 - 單例模式

[4]. Java中的雙重檢查鎖(double checked locking)

相關文章