Java 實現單例模式的 9 種方法

一. 什麼是單例模式

因進程需要，有時我們只需要某個類同時保留一個對象，不希望有更多對象，此時，我們則應考慮單例模式的設計。

二. 單例模式的特點

單例模式只能有一個實例。

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

單例類必須向其他對象提供這一實例。

三. 單例模式VS靜態類

在知道了什麼是單例模式後，我想你一定會想到靜態類，“既然只使用一個對象，為何不乾脆使用靜態類？”，這裡我會將單例模式和靜態類進行一個比較。

單例可以繼承和被繼承，方法可以被override，而靜態方法不可以。

靜態方法中產生的對象會在執行後被釋放，進而被GC清理，不會一直存在於內存中。

靜態類會在第一次運行時初始化，單例模式可以有其他的選擇，即可以延遲加載。

基於2，3條，由於單例對象往往存在於DAO層（例如sessionFactory），如果反覆的初始化和釋放，則會佔用很多資源，而使用單例模式將其常駐於內存可以更加節約資源。

靜態方法有更高的訪問效率。

單例模式很容易被測試。

幾個關於靜態類的誤解：

誤解一：靜態方法常駐內存而實例方法不是。

實際上，特殊編寫的實例方法可以常駐內存，而靜態方法需要不斷初始化和釋放。

誤解二：靜態方法在堆(heap)上，實例方法在棧(stack)上。

實際上，都是加載到特殊的不可寫的代碼內存區域中。

靜態類和單例模式情景的選擇：

情景一：不需要維持任何狀態，僅僅用於全局訪問，此時更適合使用靜態類。

情景二：需要維持一些特定的狀態，此時更適合使用單例模式。

四. 單例模式的實現

1. 懶漢模式（線程不安全）

<code>public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}/<code>

如上，通過提供一個靜態的對象instance，利用private權限的構造方法和getInstance()方法來給予訪問者一個單例。

缺點是，沒有考慮到線程安全，可能存在多個訪問者同時訪問，並同時構造了多個對象的問題。之所以叫做懶漢模式，主要是因為此種方法可以非常明顯的lazy loading。

針對懶漢模式線程不安全的問題，我們自然想到了，在getInstance()方法前加鎖，於是就有了第二種實現。

2. 線程安全的懶漢模式（線程安全）

<code>public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){

    }
    public static synchronized SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}/<code>

然而併發其實是一種特殊情況，大多時候這個鎖佔用的額外資源都浪費了，這種打補丁方式寫出來的結構效率很低。

3. 餓漢模式（線程安全）

<code>public class SingletonDemo {
    private static SingletonDemo instance=new SingletonDemo();
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        return instance;
    }
}/<code>

直接在運行這個類的時候進行一次loading，之後直接訪問。顯然，這種方法沒有起到lazy loading的效果，考慮到前面提到的和靜態類的對比，這種方法只比靜態類多了一個內存常駐而已。

4. 靜態類內部加載（線程安全）

<code>public class SingletonDemo {
    private static class SingletonHolder{
        private static SingletonDemo instance=new SingletonDemo();
    }
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        return SingletonHolder.instance;
    }
}/<code>

使用內部類的好處是，靜態內部類不會在單例加載時就加載，而是在調用getInstance()方法時才進行加載，達到了類似懶漢模式的效果，而這種方法又是線程安全的。

5. 枚舉方法（線程安全）

<code>enum SingletonDemo{
    INSTANCE;
    public void otherMethods(){
        System.out.println("Something");
    }
}/<code>

Effective Java作者Josh Bloch 提倡的方式，在我看來簡直是來自神的寫法。解決了以下三個問題：

(1)自由串行化。

(2)保證只有一個實例。

(3)線程安全。

如果我們想調用它的方法時，僅需要以下操作：

<code>public class Hello {
    public static void main(String[] args){
        SingletonDemo.INSTANCE.otherMethods();
    }
}/<code>

這種充滿美感的代碼真的已經終結了其他一切實現方法了。

Josh Bloch 對這個方法的評價：

6. 雙重校驗鎖法（通常線程安全，低概率不安全）

<code>public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}/<code>

接下來我解釋一下在併發時，雙重校驗鎖法會有怎樣的情景：

STEP 1. 線程A訪問getInstance()方法，因為單例還沒有實例化，所以進入了鎖定塊。

STEP 2. 線程B訪問getInstance()方法，因為單例還沒有實例化，得以訪問接下來代碼塊，而接下來代碼塊已經被線程1鎖定。

STEP 3. 線程A進入下一判斷，因為單例還沒有實例化，所以進行單例實例化，成功實例化後退出代碼塊，解除鎖定。

STEP 4. 線程B進入接下來代碼塊，鎖定線程，進入下一判斷，因為已經實例化，退出代碼塊，解除鎖定。

STEP 5. 線程A獲取到了單例實例並返回，線程B沒有獲取到單例並返回Null。

理論上雙重校驗鎖法是線程安全的，並且，這種方法實現了lazyloading。

7. 第七種終極版 （volatile）

對於6中Double-Check這種可能出現的問題（當然這種概率已經非常小了，但畢竟還是有的嘛~），解決方案是：只需要給instance的聲明加上volatile關鍵字即可，volatile版本如下：

<code>public class Singleton{
    private volatile static Singleton singleton = null;
    private Singleton()  {    }
    public static Singleton getInstance()   {
        if (singleton== null)  {
            synchronized (Singleton.class) {
                if (singleton== null)  {
                    singleton= new Singleton();
                }
            }
        }
        return singleton;
    }
}/<code>

volatile關鍵字的一個作用是禁止指令重排，把instance聲明為volatile之後，對它的寫操作就會有一個內存屏障（什麼是內存屏障？），這樣，在它的賦值完成之前，就不用會調用讀操作。

8. 使用ThreadLocal實現單例模式（線程安全）

<code>public class Singleton {
    private static final ThreadLocal tlSingleton =
            new ThreadLocal() {
                @Override
                protected Singleton initialValue() {
                    return new Singleton();
                }
            };
    /**
     * Get the focus finder for this thread.
     */
    public static Singleton getInstance() {
        return tlSingleton.get();
    }
    // enforce thread local access
    private Singleton() {}
}/<code>

ThreadLocal會為每一個線程提供一個獨立的變量副本，從而隔離了多個線程對數據的訪問衝突。對於多線程資源共享的問題，同步機制採用了“以時間換空間”的方式，而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變量，讓不同的線程排隊訪問，而後者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。

9. 使用CAS鎖實現（線程安全）

<code>/**
 * 更加優美的Singleton, 線程安全的
 */
public class Singleton {
 /** 利用AtomicReference */
 private static final AtomicReference INSTANCE = new AtomicReference();
 /**
  * 私有化
  */
 private Singleton(){
 }
 /**
  * 用CAS確保線程安全
  */
 public static final Singleton getInstance(){
  for (;;) {
   Singleton current = INSTANCE.get();
            if (current != null) {
                return current;
            }
            current = new Singleton();
            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
 }

 public static void main(String[] args) {
  Singleton singleton1 = Singleton.getInstance();
  Singleton singleton2 = Singleton.getInstance();
     System.out.println(singleton1 == singleton2);
 }
}/<code>

優逸客（微信公眾號sx-uek）UI設計、Web全棧開發、JAVA開發等課程免費試聽課火熱報名中，願這個時代的每個人都可以站在風口，成就更好的自己！