點擊上方“好好學java”，選擇“置頂公眾號”

優秀學習資源、干貨第一時間送達！

好好學java

java知識分享/學習資源免費分享

關注

?精彩內容?

java實戰練習項目教程

全網最全電子圖書分享

你所需要的大數據視頻教程

java全套學習視頻教程及源碼

一、特點

　　1、單例類只能有一個實例。
　　2、單例類必須自己創建自己的唯一實例。
　　3、單例類必須給所有其他對象提供這一實例。

　 　單例模式確保某個類只有一個實例，而且自行實例化并向整個系統提供這個實例。

二．分類

(一)、懶漢式單例

//懶漢式單例類.在第一次調用的時候實例化自己??? public?class?Singleton?{//?構造方法私有化private?Singleton()?{}private?static?Singleton?single?=?null;//?靜態工廠方法public?static?Singleton?getInstance()?{if?(single?==?null)?{single?=?new?Singleton();}return?single;} }

Singleton通過將構造方法限定為private避免了類在外部被實例化，在同一個虛擬機范圍內，Singleton的唯一實例只能通過getInstance()方法訪問。（事實上，通過Java反射機制是能夠實例化構造方法為private的類的，那基本上會使所有的Java單例實現失效。此問題在此處不做討論，姑且掩耳盜鈴地認為反射機制不存在。）

但是以上懶漢式單例的實現沒有考慮線程安全問題，它是線程不安全的，并發環境下很可能出現多個Singleton實例，要實現線程安全，有以下三種方式，都getInstance這個方法改造，保證了懶漢式單例的線程安全，如果你第一次接觸單例模式，對線程安全不是很了解，可以先跳過下面這三小條，去看 餓漢式單例，等看完后面再回頭考慮線程安全的問題：

1、在getInstance方法上加同步

public?static?synchronized??Singleton?getInstance()?{if?(single?==?null)?{single?=?new?Singleton();}return?single; }

2、雙重檢查鎖定

可以使用“雙重檢查加鎖”的方式來實現，就可以既實現線程安全，又能夠使性能不受很大的影響。那么什么是“雙重檢查加鎖”機制呢？

所謂“雙重檢查加鎖”機制，指的是：并不是每次進入getInstance方法都需要同步，而是先不同步，進入方法后，先檢查實例是否存在，如 果不存在才進行下面的同步塊，這是第一重檢查，進入同步塊過后，再次檢查實例是否存在，如果不存在，就在同步的情況下創建一個實例，這是第二重檢查。這樣 一來，就只需要同步一次了，從而減少了多次在同步情況下進行判斷所浪費的時間。

“雙重檢查加鎖”機制的實現會使用關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。

注意：在java1.4及以前版本中，很多JVM對于volatile關鍵字的實現的問題，會導致“雙重檢查加鎖”的失敗，因此“雙重檢查加鎖”機制只只能用在java5及以上的版本。

public?class?Singleton?{private?volatile?static?Singleton?instance?=?null;private?Singleton(){}public?static?Singleton?getInstance(){//先檢查實例是否存在，如果不存在才進入下面的同步塊if(instance?==?null){//同步塊，線程安全的創建實例synchronized?(Singleton.class)?{//再次檢查實例是否存在，如果不存在才真正的創建實例if(instance?==?null){instance?=?new?Singleton();}}}return?instance;} }

這種實現方式既可以實現線程安全地創建實例，而又不會對性能造成太大的影響。它只是第一次創建實例的時候同步，以后就不需要同步了，從而加快了運行速度。

(摘自網絡)提示：由于volatile關鍵字可能會屏蔽掉虛擬機中一些必要的代碼優化，所以運行效率并不是很高。因此一般建議，沒有特別的需要，不要使用。也就是說，雖然可以使用“雙重檢查加鎖”機制來實現線程安全的單例，但并不建議大量采用，可以根據情況來選用。

(三)、靜態(類級)內部類

public?class?Singleton?{private?Singleton(){}/***????類級的內部類，也就是靜態的成員式內部類，該內部類的實例與外部類的實例*????沒有綁定關系，而且只有被調用到時才會裝載，從而實現了延遲加載。*/private?static?class?SingletonHolder{/***?靜態初始化器，由JVM來保證線程安全*/private?static?Singleton?instance?=?new?Singleton();}public?static?Singleton?getInstance(){return?SingletonHolder.instance;} }

這種比上面1、2都好一些，既實現了線程安全，又避免了同步帶來的性能影響。　當getInstance方法第一次被調用的時候，它第一次讀取 SingletonHolder.instance，導致SingletonHolder類得到初始化；而這個類在裝載并被初始化的時候，會初始化它的靜 態域，從而創建Singleton的實例，由于是靜態的域，因此只會在虛擬機裝載類的時候初始化一次，并由虛擬機來保證它的線程安全性。

這個模式的優勢在于，getInstance方法并沒有被同步，并且只是執行一個域的訪問，因此延遲初始化并沒有增加任何訪問成本。

(四)、餓漢式單例

//餓漢式單例類.在類初始化時，已經自行實例化??? public?class?EagerSingleton?{private?static?EagerSingleton?instance?=?new?EagerSingleton();/***?構造方法私有化*/private?EagerSingleton(){}/***?靜態工廠方法*/public?static?EagerSingleton?getInstance(){return?instance;} }

餓漢式在類創建的同時就已經創建好一個靜態的對象供系統使用，以后不再改變，所以天生是線程安全的。

(五)、單例和枚舉

用枚舉來實現單例非常簡單，只需要編寫一個包含單個元素的枚舉類型即可。

public?enum?Singleton?{/***?定義一個枚舉的元素，它就代表了Singleton的一個實例。*/uniqueInstance;/***?單例可以有自己的操作*/public?void?singletonOperation(){//功能處理} }

相關測試代碼：

public?enum?SingletonEnum?{INSTANCE01,?INSTANCE02;//?定義枚舉的兩個類型private?String?name;public?String?getName()?{return?name;}public?void?setName(String?name){this.name?=?name;} }public?class?Test?{public?static?void?main(String[]?args)?{SingletonEnum?instance01=SingletonEnum.INSTANCE01;instance01.setName("tanggao");System.out.println(instance01.getName());SingletonEnum?instance02=SingletonEnum.INSTANCE01;System.out.println(instance02.getName());SingletonEnum?instance03=SingletonEnum.INSTANCE02;instance03.setName("zsy");System.out.println(instance03.getName());SingletonEnum?instance04=SingletonEnum.INSTANCE02;instance04.setName("zsy1");System.out.println(instance04.getName());System.out.println(instance03.hashCode()+"\t"+instance04.hashCode());System.out.println(instance03==instance04);} }

結果:

tanggao
tanggao
zsy
zsy1
3346521 3346521
true

使用枚舉來實現單實例控制會更加簡潔，而且無償地提供了序列化機制，并由JVM從根本上提供保障，絕對防止多次實例化，是更簡潔、高效、安全的實現單例的方式。

三、餓漢式和懶漢式區別

從名字上來說，餓漢和懶漢，
餓漢就是類一旦加載，就把單例初始化完成，保證getInstance的時候，單例是已經存在的了，
而懶漢比較懶，只有當調用getInstance的時候，才回去初始化這個單例。
另外從以下兩點再區分以下這兩種方式：

1、線程安全：
餓漢式天生就是線程安全的，可以直接用于多線程而不會出現問題，
懶漢式本身是非線程安全的，為了實現線程安全有幾種寫法，分別是上面的1、2、3，這三種實現在資源加載和性能方面有些區別。

2、資源加載和性能：
餓漢式在類創建的同時就實例化一個靜態對象出來，不管之后會不會使用這個單例，都會占據一定的內存，但是相應的，在第一次調用時速度也會更快，因為其資源已經初始化完成，

而懶漢式顧名思義，會延遲加載，在第一次使用該單例的時候才會實例化對象出來，第一次調用時要做初始化，如果要做的工作比較多，性能上會有些延遲，之后就和餓漢式一樣了。

至于1、2、3這三種實現又有些區別，

第1種，在方法調用上加了同步，雖然線程安全了，但是每次都要同步，會影響性能，畢竟99%的情況下是不需要同步的，

第2種，在getInstance中做了兩次null檢查，確保了只有第一次調用單例的時候才會做同步，這樣也是線程安全的，同時避免了每次都同步的性能損耗

第3種，保證初始化instance時只有一個線程，所以也是線程安全的，同時沒有性能損耗，一般傾向于使用這一種。

3、什么是線程安全？

如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。

或者說：一個類或者程序所提供的接口對于線程來說是原子操作，或者多個線程之間的切換不會導致該接口的執行結果存在二義性,也就是說我們不用考慮同步的問題，那就是線程安全的。

出處:https://blog.csdn.net/tanggao1314/article/details/50565114

往期推薦

• 七夕節提前送禮了，一套java架構師學習資源等你拿
  

• 一文看透java8新特性
  

• 八月份第②期送書活動
  

????????????????????????????????????????????? ? ? ? 長按二維碼關注

總結

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

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