Java設計模式4：單例模式

前言

非常重要，單例模式是各個Java項目中必不可少的一種設計模式。本文的關注點將重點放在單例模式的寫法以及每種寫法的線程安全性上。所謂"線程安全性"的意思就是保證在創建單例對象的時候不存在競爭，只會創建出一個單例對象。

 

單例模式

作為對象的創建模式，單例模式確保其某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例，這個類稱為單例類。單例模式有以下特點：

1、單例類只能有一個實例

2、單例類必須自己創建自己的唯一實例

3、單例類必須給其他所有對象提供這一實例

下面看一下單例模式的三種寫法，除了這三種寫法，靜態內部類的方式、靜態代碼塊的方式、enum枚舉的方式也都可以，不過異曲同工，這三種方式就不寫了。

 

餓漢式

顧名思義，餓漢式，就是使用類的時候不管用的是不是類中的單例部分，都直接創建出單例類，看一下餓漢式的寫法：

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

這就是餓漢式單例模式的寫法，也是一種比較常見的寫法。這種寫法會不會造成競爭，引發線程安全問題呢？答案是不會。可能有人會覺得奇怪：

第3行，CPU執行線程A，實例化一個EagerSingleton，沒有實例化完，CPU就從線程A切換到線程B了，線程B此時也實例化這個EagerSingleton，然后EagerSingleton被實例化出來了兩次，有兩份內存地址，不就有線程安全問題了嗎？

沒關系，我們完全不需要擔心這個問題，JDK已經幫我們想到了。Java虛擬機2：Java內存區域及對象，文中可以看一下對象創建這一部分，沒有寫得很詳細，其實就是"虛擬機采用了CAS配上失敗重試的方式保證更新更新操作的原子性和TLAB兩種方式來解決這個問題"。

 

懶漢式

同樣，顧名思義，這個人比較懶，只有當單例類用到的時候才會去創建這個單例類，看一下懶漢式的寫法：

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

這種寫法基本不用，因為這是一種線程非安全的寫法。試想，線程A初次調用getInstance()方法，代碼走到第12行，線程此時切換到線程B，線程B走到12行，看到instance是null，就new了一個LazySingleton出來，這時切換回線程A，線程A繼續走，也new了一個LazySingleton出來。這樣，單例類LazySingleton在內存中就有兩份引用了，這就違背了單例模式的本意了。

可能有人會想，CPU分的時間片再短也不至於getInstance()方法只執行一個判斷就切換線程了吧？問題是，萬一線程A調用LazySingleton.getInstance()之前已經執行過別的代碼了呢，走到12行的時候剛好時間片到了，也是很正常的。

 

雙檢鎖

既然懶漢式是非線程安全的，那就要改進它。最直接的想法是，給getInstance方法加鎖不就好了，但是我們不需要給方法全部加鎖啊，只需要給方法的一部分加鎖就好了。基於這個考慮，引入了雙檢鎖（Double Check Lock，簡稱DCL）的寫法：

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

雙檢鎖的寫法是不是線程安全的呢？是的，至於為什么，不妨以分析懶漢式寫法的方式分析一下雙檢鎖的寫法。

線程A初次調用DoubleCheckLockSingleton.getInstance()方法，走12行，判斷instance為null，進入同步代碼塊，此時線程切換到線程B，線程B調用DoubleCheckLockSingleton.getInstance()方法，由於同步代碼塊外面的代碼還是異步執行的，所以線程B走12行，判斷instance為null，等待鎖。結果就是線程A實例化出了一個DoubleCheckLockSingleton，釋放鎖，線程B獲得鎖進入同步代碼塊，判斷此時instance不為null了，並不實例化DoubleCheckLockSingleton。這樣，單例類就保證了在內存中只存在一份。

 

單例模式在Java中的應用及解讀

Runtime是一個典型的例子，看下JDK API對於這個類的解釋"每個Java應用程序都有一個Runtime類實例，使應用程序能夠與其運行的環境相連接，可以通過getRuntime方法獲取當前運行時。應用程序不能創建自己的Runtime類實例。"，這段話，有兩點很重要：

1、每個應用程序都有一個Runtime類實例

2、應用程序不能創建自己的Runtime類實例

只有一個、不能自己創建，是不是典型的單例模式？看一下，Runtime類的寫法：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance 
     * methods and must be invoked with respect to the current runtime object. 
     * 
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() { 
    return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

    ...
}

后面的就不黏貼了，到這里已經足夠了，看到Runtime使用getRuntime()方法並讓構造方法私有保證程序中只有一個Runtime實例且Runtime實例不可以被用戶創建。

 

單例模式的好處

作為一種重要的設計模式，單例模式的好處有：

1、控制資源的使用，通過線程同步來控制資源的並發訪問

2、控制實例的產生，以達到節約資源的目的

3、控制數據的共享，在不建立直接關聯的條件下，讓多個不相關的進程或線程之間實現通信