一. 什么是單例模式

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

二. 單例模式的特點

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

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

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

三. 單例模式VS靜態類

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

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

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

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

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

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

單例模式很容易被測試。

幾個關于靜態類的誤解：

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

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

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

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

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

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

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

四. 單例模式的實現

懶漢模式（線程不安全）

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()方法前加鎖，于是就有了第二種實現。

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

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

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

餓漢模式（線程安全）

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

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

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

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()方法時才進行加載，達到了類似懶漢模式的效果，而這種方法又是線程安全的。

枚舉方法（線程安全）

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

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

Josh Bloch 對這個方法的評價：
這種寫法在功能上與共有域方法相近，但是它更簡潔，無償地提供了串行化機制，絕對防止對此實例化，即使是在面對復雜的串行化或者反射攻擊的時候。雖然這中方法還沒有廣泛采用，但是單元素的枚舉類型已經成為實現Singleton的最佳方法。
枚舉單例這種方法問世以來，許多分析文章都稱它是實現單例的最完美方法——寫法超級簡單，而且又能解決大部分的問題。
不過我個人認為這種方法雖然很優秀，但是它仍然不是完美的——比如，在需要繼承的場景，它就不適用了。

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

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

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

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

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

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

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

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

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

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

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

volatile關鍵字的一個作用是禁止指令重排，把instance聲明為volatile之后，對它的寫操作就會有一個內存屏障（什么是內存屏障？），這樣，在它的賦值完成之前，就不用會調用讀操作。
注意：volatile阻止的不singleton = newSingleton()這句話內部[1-2-3]的指令重排，而是保證了在一個寫操作（[1-2-3]）完成之前，不會調用讀操作（if (instance == null)）。
也就徹底防止了6中的問題發生。

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

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

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

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

/***?更加優美的Singleton,?線程安全的*/ public?class?Singleton?{/**?利用AtomicReference?*/private?static?final?AtomicReference<Singleton>?INSTANCE?=?new?AtomicReference<Singleton>();/***?私有化*/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);} }

總結

以上是生活随笔為你收集整理的Java 实现单例模式的 9 种方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。