Java公開課-06.單例

標籤：src   alt   tac   解釋   main   tle   訪問   copy   有一個   

一. 什麼是單例模式

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

二. 單例模式的特點

1. 單例模式只能有一個執行個體。

2. 單例類必須建立自己的唯一執行個體。

3. 單例類必須向其他對象提供這一執行個體。

三. 單例模式VS靜態類

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

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

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

3. 靜態類會在第一次運行時初始化，單例模式可以有其他的選擇，即可以消極式載入。

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

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

6. 單例模式很容易被測試。

幾個關於靜態類的誤解：

誤解一：靜態方法常駐記憶體而執行個體方法不是。

實際上，特殊編寫的執行個體方法可以常駐記憶體，而靜態方法需要不斷初始化和釋放。

誤解二：靜態方法在堆(heap)上，執行個體方法在棧(stack)上。

實際上，都是載入到特殊的不可寫的代碼記憶體地區中。

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

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

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

四. 單例模式的實現

1. 懶漢模式

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

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

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

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

2. 安全執行緒的懶漢模式

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

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

3. 餓漢模式

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

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

4. 靜態類內部載入

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;    }}

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

5. 枚舉方法

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

 

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

(1)自由序列化。

(2)保證只有一個執行個體。

(3)安全執行緒。

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

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

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

6. 雙重校正鎖法

public class SingletonDemo {    private volatile 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;    }}

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

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

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

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

STEP 4. 線程B進入接下來代碼塊，鎖定線程，進入下一判斷，因為已經執行個體化，結束代碼塊，解除鎖定。

STEP 5. 線程A擷取到了單例執行個體並返回，線程B沒有擷取到單例並返回Null。

理論上雙重校正鎖法是安全執行緒的，並且，這種方法實現了lazyloading。

Java公開課-06.單例