2. 程式人生 > >8種單例模式寫法助你搞定面試

8種單例模式寫法助你搞定面試

阿新 • • 發佈：2019-08-22

1. 單例模式常見問題

為什麼要有單例模式

單例模式是一種設計模式，它限制了例項化一個物件的行為，始終至多隻有一個例項。當只需要一個物件來協調整個系統的操作時，這種模式就非常有用.它描述瞭如何解決重複出現的設計問題，
比如我們專案中的配置工具類,日誌工具類等等。

如何設計單例模式 ?

1.單例類如何控制其例項化

2.如何確保只有一個例項

通過一下措施解決這些問題：

private建構函式,類的例項話不對外開放,由自己內部來完成這個操作,確保永遠不會從類外部例項化類,避免外部隨意new出來新的例項。

該例項通常儲存為私有靜態變數，提供一個靜態方法，返回對例項的引用。如果是在多執行緒環境下則用鎖或者內部類來解決執行緒安全性問題。

2. 單例類有哪些特點 ?

私有建構函式
它將阻止從類外部例項化新物件

它應該只有一個例項
這是通過在類中提供例項來方法完成的,阻止外部類或子類來建立例項。這是通過在java中使建構函式私有來完成的，這樣任何類都不能訪問建構函式，因此無法例項化它。

單例項應該是全域性可訪問的
單例類的例項應該是全域性可訪問的，以便每個類都可以使用它。在Java中，它是通過使例項的訪問說明符為public來完成的。

節省記憶體,減少GC

因為是全域性至多隻有一個例項，避免了到處new物件,造成浪費記憶體,以及GC，有了單例模式可以避免這些問題

3. 單例模式8種寫法

下面由我給大家介紹8種單例模式的寫法,各有千秋,存在即合理，通過自己的使用場景選一款使用即可。我們選擇單例模式時的挑選標準或者說評估一種單例模式寫法的優劣時通常會根據一下兩種因素來衡量:

1.在多執行緒環境下行為是否執行緒安全

2.餓漢以及懶漢

3.編碼是否優雅(理解起來是否比較直觀)

1. 餓漢式執行緒安全的

public class SingleTon{

    private static final SingleTon INSTANCE = new SingleTon();

    private SingleTon(){ }

    public static SingleTon getInstance(){
        return INSTANCE;
    }
    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
    }

}

這種寫法是非常簡單實用的，值得推薦，唯一缺點就是懶漢式的，也就是說不管是否需要用到這個方法，當類載入的時候都會生成一個物件。
除此之外，這種寫法是執行緒安全的。類載入到記憶體後，就例項化一個單例，JVM保證執行緒安全，

2. 餓漢式執行緒安全(變種寫法)。

public class SingleTon{

    private static final SingleTon INSTANCE ;

    static {
        INSTANCE = new SingleTon(); 
    }

    private SingleTon(){}

    public static SingleTon getInstance(){
        return INSTANCE;
    }
        public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
    }

}

3. 懶漢式執行緒不安全。

public class SingleTon{

    private static  SingleTon instance ;

    private SingleTon(){}

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

    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

這種寫法雖然達到了按需初始化的目的，但卻帶來執行緒不安全的問題，至於為什麼在併發情況下上述的例子是不安全的呢 ?

   // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }

為了使效果更直觀一點我們對getInstance 方法稍做修改,每個執行緒進入之後休眠一毫秒，這樣做的目的是為了每個執行緒都儘可能獲得cpu時間片去執行。程式碼如下
public static SingleTon getInstance(){ if(instance == null){ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } instance = new SingleTon(); } return instance; }

執行結果如下

上述的單例寫法，我們是可以創造出多個例項的，至於為什麼在這裡要稍微解釋一下,這裡涉及了同步問題

造成執行緒不安全的原因：

當併發訪問的時候，第一個呼叫getInstance方法的執行緒t1，在判斷完singleton是null的時候，執行緒A就進入了if塊準備創造例項，但是同時另外一個執行緒B線上程A還未創造出例項之前，就又進行了singleton是否為null的判斷，這時singleton依然為null，所以執行緒B也會進入if塊去創造例項，這時問題就出來了，有兩個執行緒都進入了if塊去創造例項，結果就造成單例模式並非單例。
注:這裡通過休眠一毫秒來模擬執行緒掛起,為初始化完instance

為了解決這個問題,我們可以採取加鎖措施,所以有了下面這種寫法

4. 懶漢式執行緒安全(粗粒度Synchronized)。

public class SingleTon{

    private static  SingleTon instance ;

    private SingleTon(){}

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

    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
            // 通過開啟100個執行緒 比較是否是相同物件
            for(int i=0;i<100;i++){
                new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

由於第三種方式出現了執行緒不安全的問題,所以對getInstance方法加了synchronized來保證多執行緒環境下的執行緒安全性問題，這種做法雖解決了多執行緒問題但是效率比較低。
因為鎖住了整個方法，其他進入的現成都只能阻塞等待了，這樣會造成很多無謂的等待。

於是可能有人會想到可不可以讓鎖的粒度更細一點,只鎖住相關程式碼塊可否？所以有了第五種寫法。

5. 懶漢式執行緒不安全(synchronized程式碼塊)

public class SingleTon{

    private static  SingleTon instance ;

    private SingleTon(){}

    public static SingleTon getInstance(){
        if(insatnce == null){
            synchronied(SingleTon.class){
                    instance = new SingleTon();
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

當併發訪問的時候，第一個呼叫getInstance方法的執行緒t1，在判斷完instance是null的時候，執行緒A就進入了if塊並且持有了synchronized鎖，但是同時另外一個執行緒t2線上程t1還未創造出例項之前，就又進行了instance是否為null的判斷，這時instance依然為null，所以執行緒t2也會進入if塊去創造例項，他會在synchronized程式碼外面阻塞等待，直到t1釋放鎖，這時問題就出來了，有兩個執行緒都例項化了新的物件。

造成這個問題的原因就是執行緒進入了if塊並且在等待synchronized鎖的過程中有可能上一個執行緒已經建立了例項,所以進入synchronized程式碼塊之後還需要在判斷一次,於是有了下面這種雙重檢驗鎖的寫法。

6. 懶漢式執行緒安全(雙重檢驗加鎖)

public class SingleTon{

    private static  volatile SingleTon instance ;

    private SingleTon(){}

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

    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

這種寫法基本趨於完美了，但是可能需要對一下幾點需要進行解釋：

  • 第一個判空(外層)的作用 ？
  • 第二個判空(內層)的作用 ？
  • 為什麼變數修飾為volatile ？

第一個判空(外層)的作用

首先，思考一下可不可以去掉最外層的判斷？ 答案是：可以

其實仔細觀察之後會發現最外層的判斷跟能否執行緒安全正確生成單例無關！！！

它的作用是避免每次進來都要加鎖或者等待鎖，有了同步程式碼塊之外的判斷之後省了很多事，當我們的單例類例項化一個單例之後其他後續的所有請求都沒必要在進入同步程式碼塊繼續往下執行了，直接返回我們曾生成的例項即可，也就是例項還未建立時才進行同步，否則就直接返回，這樣就節省了很多無謂的執行緒等待時間，所以最外的判斷可以認為是對提升效能有幫助。

第二個判空(內層)的作用

假設我們去掉同步塊中的是否為null的判斷，有這樣一種情況，A執行緒和B執行緒都在同步塊外面判斷了instance為null，結果t1執行緒首先獲得了執行緒鎖，進入了同步塊，然後t1執行緒會創造一個例項，此時instance已經被賦予了例項，t1執行緒退出同步塊，直接返回了第一個創造的例項，此時t2執行緒獲得執行緒鎖，也進入同步塊，此時t1執行緒其實已經創造好了例項，t2執行緒正常情況應該直接返回的，但是因為同步塊裡沒有判斷是否為null，直接就是一條建立例項的語句，所以t2執行緒也會創造一個例項返回，此時就造成創造了多個例項的情況。

為什麼變數修飾為volatile

因為虛擬機器在執行建立例項的這一步操作的時候，其實是分了好幾步去進行的，也就是說建立一個新的物件並非是原子性操作。在有些JVM中上述做法是沒有問題的，但是有些情況下是會造成莫名的錯誤。

首先要明白在JVM建立新的物件時，主要要經過三步。

1.分配記憶體

2.初始化構造器

3.將物件指向分配的記憶體的地址

因為僅僅一個new 新例項的操作就涉及三個子操作,所以生成物件的操作不是原子操作

而實際情況是，JVM會對以上三個指令進行調優，其中有一項就是調整指令的執行順序(該操作由JIT編譯器來完成)。

所以，在指令被排序的情況下可能會出現問題，假如 2和3的步驟是相反的，先將分配好的記憶體地址指給instance，然後再進行初始化構造器，這時候後面的執行緒去請求getInstance方法時，會認為instance物件已經例項化了，直接返回一個引用。

如果這時還沒進行構造器初始化並且這個執行緒使用了instance的話，則會出現執行緒會指向一個未初始化構造器的物件現象，從而發生錯誤。

7. 靜態內部類的方式(基本完美了)

public class SingleTon{

    public static SingleTon getInstance(){
        return StaticSingleTon.instance;
    }
    private static class StaticSingleTon{
            private static final SingleTon instance = new SingleTon();
    }
    public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}
  • 因為一個類的靜態屬性只會在第一次載入類時初始化，這是JVM幫我們保證的，所以我們無需擔心併發訪問的問題。所以在初始化進行一半的時候，別的執行緒是無法使用的，因為JVM會幫我們強行同步這個過程。
  • 另外由於靜態變數只初始化一次，所以singleton仍然是單例的。

8. 列舉型別的單例模式(太完美以至於。。。)

public Enum SingleTon{
    
    INSTANCE;
    public static void main(String[] args) {
         // 通過開啟100個執行緒 比較是否是相同物件
        for(int i=0;i<100;i++){
            new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

這種寫法從語法上看來是完美的,他解決了上面7種寫法都有的問題,就是我們可以通過反射可以生成新的例項。
但是列舉的這種寫法是無法通過反射來生成新的例項,因為列舉沒有public構造方法

相關推薦

8種單例模式寫法助你搞定面試

1. 單例模式常見問題 為什麼要有單例模式 單例模式是一種設計模式，它限制了例項化一個物件的行為，始終至多隻有一個例項。當只需要一個物件來協調整個系統的操作時，這種模式就非常有用.它描述瞭如何解決重複出現的設計問題， 比如我們專案中的配置工具類,日誌工具類等等。 如何設計單例模式 ? 1.單例類如何控制其例項

常見的七種單例模式寫法

public enum Singleton { instance; public void operate(){ System.out.println("處理中。。。。"); } } 驗證是否是同一物件: Singleton singletest1 =Singleton.inst

android 幾種單例模式的寫法

首先，先不論單例模式的寫法，有些方面是相同的，比如都需要將唯一的物件設定為static的，都需要將構造方法private化，程式碼如下： public class MyInstance { private static MyInstance instance;

你知道幾種單例模式？

大家好，先簡單自我介紹一下啊，我呢現在是在做Android這一塊，做這一塊大概快兩年了。工作地是在河南鄭州。在開始之前呢，首先感謝一下宇明兄弟啊，因為自己當初寫部落格的習慣是通過他的啟發才開始，現在又做這一塊語音文字的方式分享技術，我感覺挺有意義的，通過這種分享不僅能讓那

快速理解Java中的五種單例模式

嵌套類 ati class 由於 aop 適合 singleton 重復 code 解法一：只適合單線程環境（不好） package test; /** * @author xiaoping * */ public class Singleton { pri

三種單例模式與Object祖先類

三種單例模式 object 單例有三種模式，懶漢式，餓漢式，和優化後的懶漢式 餓漢式單例模式： 餓漢式就像饑餓的人一樣先把事情都提前準備好，因為它是先在靜態屬性裏先提前構建好對象，然後再用靜態方法將對象返回出去，所以會提前占用資源，但是速度比較快。例如：懶漢式單例模式： 懶漢式就像懶人一樣要等到事

五種單例模式----來自腳本之家

example cin args pytho single main 屬性 code 添加 本文為大家分享了Python創建單例模式的5種常用方法，供大家參考，具體內容如下 所謂單例，是指一個類的實例從始至終只能被創建一次。 方法1： 如果想使得某個類從始至終最多只有一個

常見的幾種單例模式

任務 ron 解決方案 程序 反序 ola hat 例如 明顯 　　單例模式：是一種常用的軟件設計模式，在它的核心結構中值包含一個被稱為單例的特殊類。一個類只有一個實例，即一個類只有一個對象實例。 　　對於系統中的某些類來說，只有一個實例很重要，例如，一個系統中可以存在多個

常見的單例模式寫法

單例模式是面試中最常被問到的地方，那麼如何理解單例模式呢？ 單例模式的特點：　　1、單例類只能有一個例項。 　　2、單例類必須自己自己建立自己的唯一例項。 　　3、單例類必須給所有其他物件提供這一例項。 單例在寫法上又分為懶漢模式（執行緒安全，執行緒不安全）、餓漢模式（天生執行緒安全）、雙重

Kotlin實現常用的五種單例模式

廢話不多說，直接上程式碼，記錄一下，方便以後使用 class ImageClassifyUtil private constructor(){ /** * 餓漢 */ companion object { val instance

C++的三種單例模式-----深度解析

三種單例模式轉自部落格：http://blog.csdn.net/q_l_s/article/details/52369065 小編想要對三種的單例模式做下解析 簡介         因為在設計或開發中，肯定會有這麼一種情況，一個類只能有一個物件

併發下的單例模式寫法。

錯誤示例： public class Singleton { private static Singleton singleton; private Singleton(){} public static Singleton getInstance(){

java設計模式精講 Debug 方式+記憶體分析 第8章 單例模式

單例模式 8-1 單例模式講解 8-2 單例設計模式-懶漢式及多執行緒Debug實戰 8-3 單例設計模式-DoubleCheck雙重檢查實戰及原理解析 8-4 單例設計模式-靜態內部類-基於類初始化的延遲載入解決方案及原理解析 8-5 單例設計

C#中三種單例模式

一、經典模式：     public class DoSomething     {         private static DoSomething doSomething;         private DoSomething() { }         pu

兩種單例模式比較（懶漢式、惡漢式）

Java 是一種面向物件的程式語言，通常一個類都有很多物件。實際應用中，我們需要某個特定的類只有一個物件，這就是單例模式。 注意：單例物件都是靜態的物件，為了保證物件是單例物件，必須私有化構造方法，並提供一個公共的靜態方法供外界呼叫來取得單例物件。 懶漢式單

三種單例模式的C++實現

簡介         因為在設計或開發中，肯定會有這麼一種情況，一個類只能有一個物件被建立，如果有多個物件的話，可能會導致狀態的混亂和不一致。這種情況下，單例模式是最恰當的解決辦法。它有很多種實現方式，各自的特性不相同，使用的情形也不相同。今天要實現的是常用的三種，分別

Java五種單例模式與執行緒安全

單例模式是一種常用的軟體設計模式，常被用於一個類在系統中最多隻允許存在一個例項的場合，如視窗管理器、列印緩衝池、檔案系統等。在單例模式的核心結構中，只包含一個被稱為單例類的特殊類。通過單例模式可以保證系統中一個類只有一個例項而且該例項易於外界訪問，從而方便對例項個數的控制並節約系統資源。如果希望在系統中某個類

五種單例模式

1、餓漢式 public class SingletonHungry { private SingletonHungry () { } private static Sin

JAVA設計模式之單例模式-快速理解Java中的五種單例模式(轉)

百度百科對單例模式的介紹 顯然單例模式的要點有三個；一是某個類只能有一個例項；二是它必須自行建立這個例項；三是它必須自行向整個系統提供這個例項。 從具體實現角度來說，就是以下三點：一是單例模式的類只提供私有的建構函式，二是類定義中含有一個該類的靜態私有物件，三是該

java常用的幾種單例模式（懶漢式、餓漢式、登記式）

簡單的講，單例模式就是確保某個類只有一個例項，而且自行例項化並向整個系統提供這個例項。 何時用到？執行緒池、快取、日誌物件、對話方塊、顯示卡驅動程式、印表機中都用到，spring中用的最多:Spring Context Factory用的是單例，bean預設都是