一、首先介紹一下單例模式：?
??? 單例模式（Singleton），也叫單子模式，是一種常用的軟件設計模式。在應用這個模式時，單例對象的類必須保證只有一個實例存在。許多時候整個系統只需要擁有一個的全局對象，這樣有利于我們協調系統整體的行為。比如在某個服務器程序中，該服務器的配置信息存放在一個文件中，這些配置數據由一個單例對象統一讀取，然后服務進程中的其他對象再通過這個單例對象獲取這些配置信息。這種方式簡化了在復雜環境下的配置管理。?

實現單例模式的思路是：?
??? 一個類能返回對象一個引用(永遠是同一個)和一個獲得該實例的方法（必須是靜態方法，通常使用getInstance這個名 稱）；當我們調用這個方法時，如果類持有的引用不為空就返回這個引用，如果類保持的引用為空就創建該類的實例并將實例的引用賦予該類保持的引用；同時我們 還將該類的構造函數定義為私有方法，這樣其他處的代碼就無法通過調用該類的構造函數來實例化該類的對象，只有通過該類提供的靜態方法來得到該類的唯一實例。?

需要注意的地方：?
??? 單例模式在多線程的 應用場合下必須小心使用。如果當唯一實例尚未創建時，有兩個線程同時調用創建方法，那么它們同時沒有檢測到唯一實例的存在，從而同時各自創建了一個實例， 這樣就有兩個實例被構造出來，從而違反了單例模式中實例唯一的原則。 解決這個問題的辦法是為指示類是否已經實例化的變量提供一個互斥鎖(雖然這樣會降低效率)。

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

二. 單例模式的特點

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

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

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

三. 單例模式VS靜態類

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

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

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

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

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

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

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

幾個關于靜態類的誤解：

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

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

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

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

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

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

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

四. 單例模式的優缺點

優點：?
??? 1.在單例模式中，活動的單例只有一個實例，對單例類的所有實例化得到的都是相同的一個實例。這樣就 防止其它對象對自己的實例化，確保所有的對象都訪問一個實例?
??? 2.單例模式具有一定的伸縮性，類自己來控制實例化進程，類就在改變實例化進程上有相應的伸縮性。?
??? 3.提供了對唯一實例的受控訪問。?
??? 4.由于在系統內存中只存在一個對象，因此可以 節約系統資源，當 需要頻繁創建和銷毀的對象時單例模式無疑可以提高系統的性能。?
??? 5.允許可變數目的實例。?
??? 6.避免對共享資源的多重占用。?
缺點：?
??? 1.不適用于變化的對象，如果同一類型的對象總是要在不同的用例場景發生變化，單例就會引起數據的錯誤，不能保存彼此的狀態。?
??? 2.由于單利模式中沒有抽象層，因此單例類的擴展有很大的困難。?
??? 3.單例類的職責過重，在一定程度上違背了“單一職責原則”。?
??? 4.濫用單例將帶來一些負面問題，如為了節省資源將數據庫連接池對象設計為的單例類，可能會導致共享連接池對象的程序過多而出現連接池溢出；如果實例化的對象長時間不被利用，系統會認為是垃圾而被回收，這將導致對象狀態的丟失。?
使用注意事項：?
??? 1.使用時不能用反射模式創建單例，否則會實例化一個新的對象?
??? 2.使用懶單例模式時注意線程安全問題?
??? 3.餓單例模式和懶單例模式構造方法都是私有的，因而是不能被繼承的，有些單例模式可以被繼承（如登記式模式）?
適用場景：?
??? 單例模式只允許創建一個對象，因此節省內存，加快對象訪問速度，因此對象需要被公用的場合適合使用，如多個模塊使用同一個數據源連接對象等等。如：?
??? 1.需要頻繁實例化然后銷毀的對象。?
??? 2.創建對象時耗時過多或者耗資源過多，但又經常用到的對象。?
??? 3.有狀態的工具類對象。?
??? 4.頻繁訪問數據庫或文件的對象。?
以下都是單例模式的經典使用場景：?
??? 1.資源共享的情況下，避免由于資源操作時導致的性能或損耗等。如上述中的日志文件，應用配置。?
??? 2.控制資源的情況下，方便資源之間的互相通信。如線程池等。?
應用場景舉例：?
??? 1.外部資源：每臺計算機有若干個打印機，但只能有一個PrinterSpooler，以避免兩個打印作業同時輸出到打印機。內部資源：大多數軟件都有一個（或多個）屬性文件存放系統配置，這樣的系統應該有一個對象管理這些屬性文件?
??? 2. Windows的Task Manager（任務管理器）就是很典型的單例模式（這個很熟悉吧），想想看，是不是呢，你能打開兩個windows task manager嗎？ 不信你自己試試看哦~?
??? 3. windows的Recycle Bin（回收站）也是典型的單例應用。在整個系統運行過程中，回收站一直維護著僅有的一個實例。?
??? 4. 網站的計數器，一般也是采用單例模式實現，否則難以同步。?
??? 5. 應用程序的日志應用，一般都何用單例模式實現，這一般是由于共享的日志文件一直處于打開狀態，因為只能有一個實例去操作，否則內容不好追加。?
??? 6. Web應用的配置對象的讀取，一般也應用單例模式，這個是由于配置文件是共享的資源。?
??? 7. 數據庫連接池的設計一般也是采用單例模式，因為數據庫連接是一種數據庫資源。數據庫軟件系統中使用數據庫連接池，主要是節省打開或者關閉數據庫連接所引起的效率損耗，這種效率上的損耗還是非常昂貴的，因為何用單例模式來維護，就可以大大降低這種損耗。?
??? 8. 多線程的線程池的設計一般也是采用單例模式，這是由于線程池要方便對池中的線程進行控制。?
??? 9. 操作系統的文件系統，也是大的單例模式實現的具體例子，一個操作系統只能有一個文件系統。?
??? 10. HttpApplication 也是單位例的典型應用。熟悉ASP.Net(IIS)的整個請求生命周期的人應該知道HttpApplication也是單例模式，所有的HttpModule都共享一個HttpApplication實例.?
　　?
實現單利模式的原則和過程：?
??? 1.單例模式：確保一個類只有一個實例，自行實例化并向系統提供這個實例?
??? 2.單例模式分類：餓單例模式（類加載時實例化一個對象給自己的引用），懶單例模式（調用取得實例的方法如getInstance時才會實例化對象）（java中餓單例模式性能優于懶單例模式，c++中一般使用懶單例模式）?
??? 3.單例模式要素：?
??????? a.私有構造方法?
??????? b.私有靜態引用指向自己實例?
??????? c.以自己實例為返回值的公有靜態方法

?代碼的實現：

1. 懶漢模式

/**
* 類同步
*/
public class SingletonDemo {private static SingletonDemo instance;private SingletonDemo(){}public static SingletonDemo getInstance(){if(instance==null){instance=new SingletonDemo();}return instance;} }

/**
* 方法同步
*/
@Component
public class LazySingleton {

private static LazySingleton lazySingleton = null;

public static LazySingleton getInstance(){
if (lazySingleton == null){
synchronized (LazySingleton.class){ // 獲得對象鎖，然后鎖住這一段代碼
/**
* 在synchronized中的if判斷是為了防止多個線程湊巧同時第一次調用getInstance，
* 它們都會去進入synchronized塊中，因為new一個這玩意需要很多資源，所以讓它們再排隊后再判斷一次。
*/
if (lazySingleton == null){
lazySingleton = new LazySingleton();
}
}
}
return lazySingleton;
}

private LazySingleton(){
System.out.println("================================ 懶漢單利模式");
}

} ?

如上，通過提供一個靜態的對象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. 餓漢模式

/*** 餓漢式單例模式* Created by Ulegal on 2017/11/29.*/ @Component public class Singleton {/*** 設立靜態變量，直接創建實例*/private static final Singleton ourInstance = new Singleton();/*** 開放一個公有方法，判斷是否已經存在實例，有返回，沒有新建一個在返回* @return*/public static Singleton getInstance() {System.out.println("-->餓漢式單例模式開始調用公有方法返回實例");return ourInstance;}/*** 私有化構造函數*/private Singleton() {//私有化構造函數System.out.println("-->餓漢式單例模式開始調用構造函數");}

直接在運行這個類的時候進行一次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。

?

餓漢模式源碼 ： https://gitee.com/xdymemory00/DanLiMoShi.git

?

轉載于:https://www.cnblogs.com/memoryXudy/p/7929845.html

總結

以上是生活随笔為你收集整理的Java 设计模式之单利模式的全部內容，希望文章能夠幫你解決所遇到的問題。

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