一、特點

　　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设计模式(一)：单例模式的全部內容，希望文章能夠幫你解決所遇到的問題。

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