1. 程式人生 > >深入探討單例模式

深入探討單例模式

最近學習了一下單例模式,看bilibili up主“狂神說Java”講完後,發現大部分部落格都少了一個很有趣的環節,不分享出來實在是太可惜了,原視訊 https://www.bilibili.com/video/BV1K54y197iS

1、瞭解單例

這個部分小部分我相信很多部落格都講的很好,我就儘量精簡了
  1. 注意:
  • 單例類只能有一個例項
  • 這個例項由自己建立
  • 這個例項必須提供給外界
  1. 關鍵:構造器私有化
  2. 建立方法:
  • 餓漢式
  • 懶漢式

總結:我認為建立方法可以歸根於兩種,一種是餓漢式,我在類的載入的時候就建立;還有一種懶漢式,只有在我需要的時候才去建立

2、思路及實現

【餓漢模式最基本的實現】

在類載入的時候就已經建立了,這個模式下,執行緒是安全的,不同的執行緒拿到的都是同一個例項,但是,這個也存在空間浪費的問題,我不需要的時候你也載入了。

//餓漢模式
 public class HungerSingle {
    private static HungerSingle single = new HungerSingle();
    //構造器私有,外界不能通過構造方法new物件,保證唯一
    private HungerSingle() {
    }
    //提供外界獲得該單例的方法,注意方法只能是static方法,因為沒有類例項
    public static HungerSingle getInstance(){
        return single;
    }
}

【懶漢模式最基本的實現】

為了解決上述那個空間浪費問題,這時候懶漢模式就起作用了,你需要我的時候我再去建立這個例項

//懶漢模式
public class LazySingle {
    private static LazySingle single;
    //構造器私有化,禁止外部new生成物件
    private LazySingle(){
    }
    //外界獲得該單例的方法
    public static LazySingle getInstance(){
        if(single == null){
            single = new LazySingle();
        }
        return single;
    }
 }

一位熱心前輩的評論:“像你這樣寫單例,在我們公司是要被開除的。”
趁我還是學生,懷著以後不被開除的心情,繼續學習下去
原來懶漢模式下,單例執行緒是不安全的。

怎麼測試呢?如下

【測試懶漢模式執行緒不安全】

//1、構造器
private LazySingle(){
    System.out.println(Thread.currentThread().getName());
}

//建立十個執行緒
for (int i = 0; i < 10; i++) {
    new Thread(()->{
         Singleton2.getInstance();
    }).start();
}

此時你會發現,構造方法呼叫了不止一次,說明沒有實現預期的單例

平時我們解決執行緒不安全的方法:不就是執行緒不安全嘛,那好辦,加鎖

【雙重檢測鎖/DCL】

public class DCLSingle {
    private static DCLSingle single;
    private DCLSingle(){
    }
    public static DCLSingle getInstance(){
        //第一次判斷,沒有這個物件才加鎖
        if(single == null){
            //哪個需要保護,就鎖哪個
            synchronized (DCLSingle.class){
                //第二次判斷,沒有就例項化
                if(single == null){
                    single = new DCLSingle();
                }
            }
        }
        return single;
    }

}

仔細和別人程式碼一比對,發現我少了個volatile關鍵字,這是啥玩意?
不懂就問。

【volatile】
為了避免指令重排

//上述程式碼宣告上面加上volatile關鍵字
 private volatile static DCLSingle single;

啥是volatile ?

引用自別人部落格
https://www.cnblogs.com/YLsY/p/11295732.html

加volatile是為了出現髒讀的出現,保證操作的原子性

1、原子性操作:不可再分割的操作
例如:single = new DCLSingle();
其實就是兩步操作:
①new DCLSingle();//開闢堆記憶體
②singl指向對記憶體

2、髒讀
Java記憶體模型規定所有的變數都是存在主存當中,每個執行緒都有自己的工作記憶體。
執行緒對變數的所有操作都必須在工作記憶體中進行,而不能直接對主存進行操作。
並且每個執行緒不能訪問其他執行緒的工作記憶體。
變數的值何時從執行緒的工作記憶體寫回主存,無法確定。

3、指令重排
single = new DCLSingle();
先執行②
後執行①
//先指向堆記憶體,還未完成構造


【模擬情況】
①執行緒1執行,在自己的工作記憶體定義引用,先指向堆記憶體,還未構造完成
②此時執行緒2執行,它進行判斷,引用已經指向了記憶體,所以執行緒2,認為構造完成,實際還未構造完成

還有一種差點忘記說了,也是菜鳥教程說建議使用的方式

【靜態內部類實現單例】

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

你會發現它和前面講的普通餓漢式很像,我把它也歸於餓漢式一類,因為它也是直接就new Singleton,但是它卻有著懶載入的效果,而這種方式是 Singleton 類被裝載了,instance 不一定被初始化。因為 SingletonHolder 類沒有被主動使用,只有通過顯式呼叫 getInstance 方法時,才會顯式裝載 SingletonHolder 類,從而例項化 instance。

【建議】建議使用靜態內部類實現


## 3、如何破化單例(其它大部分部落格沒有的內容) 在這裡感謝b站up【狂神說java】

在面試官面前裝逼的時候來了

java語言實現動態化的靈魂——反射,說:沒有什麼是我不能改變的,看我來如何操作。

【反射破壞單例】

public class DCLSingle {
    private static DCLSingle single;
    private DCLSingle(){
    }
    public static DCLSingle getInstance(){
        //第一次判斷,沒有這個物件才加鎖
        if(single == null){
            //哪個需要保護,就鎖哪個
            synchronized (DCLSingle.class){
                //第二次判斷,沒有就例項化
                if(single == null){
                    single = new DCLSingle();
                }
            }
        }
        return single;
    }
    
    //通過反射破化單例
    public static void main(String[] args) throws Exception {
        LazySingle single = LazySingle.getInstance();
        Constructor<LazySingle> constructor = LazySingle.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        LazySingle single1 = constructor.newInstance();
        System.out.println(single == single1);//false
    }

}

得到單例類的構造器,然後通過newInstance的方法建立物件,很明顯破化了單例

【改進程式碼,防止你搞破化】

既然這次你是通過得到構造器破化的,那我給構造器加個方法,如果你已經建立了例項,那就丟擲異常

private LazySingle(){
    synchronized(LazySingle.class){
        if(single!=null){
            throw new RuntimeException("破壞失敗");
        }
    }
}

但是這個又有問題,這裡的判斷是private static DCLSingle single 是否有值,如果我們都不通過getInstance()方法建立物件,而是這樣

public static void main(String[] args) throws Exception {
 //   LazySingle single = LazySingle.getInstance();
    Constructor<LazySingle> constructor = LazySingle.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    
    //注意:這裡的物件不是單例類中裡面屬性的那個物件
    LazySingle single = constructor.newInstance();
    LazySingle single1 = constructor.newInstance();
    System.out.println(single == single1);//false
}

這裡根本不會丟擲異常,而是又破壞了單例

【繼續改進程式碼,防止搞破化】
簡直就是相愛相殺呀,我們可以利用紅路燈原理,防止破化
改進構造方法

//加個標誌
private static String sign = "password";
private LazySingle(){
    synchronized(LazySingle.class){
        if(single!=null || !"password".equals(sign)){
            throw new RuntimeException("破壞失敗");
        }else{
            sign = "no";
        }
    }
    
}

此刻你通過上述main()方法裡面的內容測試,發現又會丟擲異常。然而我們能通過反射獲得構造方法,那我們同樣也能通過反射獲取物件的屬性以及值吧

【再度破化】

public static void main(String[] args) throws Exception {
    Constructor<LazySingle> constructor = LazySingle.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Field field = LazySingle.class.getDeclaredField("sign");
    //此處省略通過反射獲取該屬性的型別和方法....
    LazySingle single1 = constructor.newInstance();
    //重新變回原標誌位
    field.set("sign","password");
    LazySingle single2 = constructor.newInstance();
    System.out.println(single2 == single1);//false
}

又被破化了

【再次改進】

我們將目光拋向列舉,
jdk1.5之後,出現列舉
利用列舉實現不僅能避免多執行緒同步問題,而且還自動支援序列化機制,防止反序列化重新建立新的物件,絕對防止多次例項化(菜鳥教程官方術語)

public enum Singleton {  
    INSTANCE;  
    public Singleton getInstance() {  
        return INSTANCE
    }  
}

【反射能破化列舉的單例嗎?】

  1. 我們先要了解列舉是啥,它的底層是怎麼實現的
  2. 我們會發現列舉本身就是一個
  3. 通過反編譯工具,檢視列舉底層的構造方法
  4. 通過反射獲取構造方
  5. 重複上述測試

我們最終可以發現反射不能破化列舉的單例

這種實現方式還沒有被廣泛採用,但這是實現單例模式的最佳方法。它更簡潔,自動支援序列化機制,絕對防止多次例項化。(菜鳥教程官方)

【總結】太難