一篇博客讀懂設計模式之---單例模式

?

一。 ?單例模式

?

? ? ? 單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在。這樣的模式有幾個好處：

1、某些類創建比較頻繁，對于一些大型的對象，這是一筆很大的系統開銷。

2、省去了new操作符，降低了系統內存的使用頻率，減輕GC壓力。

3、有些類如交易所的核心交易引擎，控制著交易流程，如果該類可以創建多個的話，系統完全亂了。所以只有使用單例模式，才能保證核心交易服務器獨立控制整個流程。

?

?

總體來說，單例模式應用的場景一般發現在以下條件下：

　　（1）資源共享的情況下，避免由于資源操作時導致的性能或損耗等。如日志文件，應用配置。

　　（2）控制資源的情況下，方便資源之間的互相通信。如線程池等。

?

有以下的特點：（eg。每臺計算機可以有若干通信端口，系統應當集中管理這些通信端口，以避免一個通信端口同時被兩個請求同時調用。為了避免不一致狀態）

?

?

1、單例類只能有一個實例。
2、單例類必須自己創建自己的唯一實例。

3、單例類必須給所有其他對象提供這一實例。

優缺點

?

優點：?（頻繁new同一個）
??? 1.在單例模式中，活動的單例只有一個實例，對單例類的所有實例化得到的都是相同的一個實例。這樣就 防止其它對象對自己的實例化，確保所有的對象都訪問一個實例?
??? 2.單例模式具有一定的伸縮性，類自己來控制實例化進程，類就在改變實例化進程上有相應的伸縮性。?
??? 3.提供了對唯一實例的受控訪問。?
??? 4.由于在系統內存中只存在一個對象，因此可以 節約系統資源，當 需要頻繁創建和銷毀的對象時單例模式無疑可以提高系統的性能。?
??? 5.允許可變數目的實例。?

??? 6.避免對共享資源的多重占用。

?

缺點：?（保存狀態，擴展職責）
??? 1.不適用于變化的對象，如果同一類型的對象總是要在不同的用例場景發生變化，單例就會引起數據的錯誤，不能保存彼此的狀態。?
??? 2.由于單例模式中沒有抽象層，因此單例類的擴展有很大的困難。?
??? 3.單例類的職責過重，在一定程度上違背了“單一職責原則”。?

??? 4.濫用單例將帶來一些負面問題，如為了節省資源將數據庫連接池對象設計為的單例類，可能會導致共享連接池對象的程序過多而出現連接池溢出；如果實例化的對象長時間不被利用，系統會認為是垃圾而被回收，這將導致對象狀態的丟失。

?

1）*懶漢式單例：Singleton通過將構造方法限定為private避免了類在外部被實例化，在同一個虛擬機范圍內，Singleton的唯一實例只能通過getInstance()方法訪問。
ps：以上懶漢式單例的實現沒有考慮線程安全問題，它是線程不安全的，并發環境下很可能出現多個Singleton實例，要實現線程安全，有以下三種方式，都是對getInstance這個方法改造，保證了懶漢式單例的線程安全，

//懶漢式單例類.在第一次調用的時候實例化自己 public class Singleton1 {//1、第一步先將構造方法私有化private Singleton1(){}//2、然后聲明一個靜態變量保存單例的引用private static Singleton1 single = null;//3、通過提供一個靜態方法來獲得單例的引用//不安全的public static Singleton1 getInstance(){if (single == null){single = new Singleton1();}return single;} } //懶漢式單例.保證線程安全 public class Singleton2 {//1、第一步先將構造方法私有化private Singleton2(){}//2、然后聲明一個靜態變量保存單例的引用private static Singleton2 single = null;//3、通過提供一個靜態方法來獲得單例的引用//為了保證多線程環境下正確訪問，給方法加上同步鎖synchronized//慎用 synchronized 關鍵字，阻塞，性能非常低下的//加上synchronized關鍵字以后，對于getInstance()方法來說，它始終單線程來訪問//沒有充分利用上我們的計算機資源，造成資源的浪費public static synchronized Singleton2 getInstance(){if(single == null){single = new Singleton2();}return single;} } //懶漢式單例.雙重鎖檢查 public class Singleton3 {//1、第一步先將構造方法私有化private Singleton3(){}//2、然后聲明一個靜態變量保存單例的引用private static Singleton3 single = null;//3、通過提供一個靜態方法來獲得單例的引用//為了保證多線程環境下的另一種實現方式，雙重鎖檢查//性能，第一次的時候public static Singleton3 getInstance(){synchronized (Singleton3.class){if (single == null){single = new Singleton3();}return single;}} }

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

public class Singleton4 {/*** 懶漢式單例* 最常用的一種模式就是這種*///1. 私有化構造器//相當于有一個默認的public的無參的構造方法，就意味著在代碼中隨時都可以new出來private Singleton4(){}//2. 生成一個靜態內部構造類//private 私有的保證別人不能修改//static 保證全局唯一private static class LazyLoader{//final 為了防止內部誤操作，代理模式，GgLib的代理模式//靜態內部類是為了防止反射獲取屬性private static final Singleton4 INSTANCE = new Singleton4();}//3、同樣提供靜態方法獲取實例//final 確保別人不能覆蓋public static Singleton4 getInstance(){//【靜態方法】中的邏輯，是要在用戶調用的時候才開始執行的//方法中實現邏輯需要分配內存，也是調用時才分配的//【區別】與靜態塊的最大區別return LazyLoader.INSTANCE;} }

還有一種注冊式：

//類似Spring里面的方法，將類名注冊，下次從里面直接獲取。 public class Singleton5 {private static Map<String,Singleton5> map = new HashMap<>();static {Singleton5 single = new Singleton5();map.put(single.getClass().getName(), single);}//靜態工廠方法,返還此類惟一的實例private Singleton5(){}public static Singleton5 getInstance(String name) throws ClassNotFoundException {if(name == null){name = Singleton5.class.getName();}if(map.get(name) == null){try{map.put(name,(Singleton5)Class.forName(name).newInstance());} catch (IllegalAccessException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();}}return map.get(name);} }

3） 餓漢式和懶漢式區別（重點）

從名字上來說，餓漢和懶漢，

餓漢就是類一旦加載，就把單例初始化完成，保證getInstance的時候，單例是已經存在的了，

而懶漢比較懶，只有當調用getInstance的時候，才回去初始化這個單例。

另外從以下兩點再區分以下這兩種方式：

1、線程安全：

餓漢式天生就是線程安全的，可以直接用于多線程而不會出現問題，

懶漢式本身是非線程安全的，為了實現線程安全有幾種寫法，分別是下面的1、2、3，這三種實現在資源加載和性能方面有些區別。

2、資源加載和性能：

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

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

1.?在getInstance方法上加同步

2. 雙重檢查鎖定：

3. 靜態內部類：

<span style="color:#3333ff">public class Singleton { private static class LazyHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton (){} public static final Singleton getInstance() { return LazyHolder.INSTANCE; } } </span>

?

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

?

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

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

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

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

以下是一個單例類使用的例子，以懶漢式為例，這里為了保證線程安全，使用了雙重檢查鎖定的方式：public String getName() { return name; } public void setName(String name) { this.name = name; } public void printInfo() { System.out.println("the name is " + name); } }

?

public class TMain { public static void main(String[] args){ TestStream ts1 = TestSingleton.getInstance(); ts1.setName("jason"); TestStream ts2 = TestSingleton.getInstance(); ts2.setName("0539"); ts1.printInfo(); ts2.printInfo(); if(ts1 == ts2){ System.out.println("創建的是同一個實例"); }else{ System.out.println("創建的不是同一個實例"); } } }

?

結論：由結果可以得知單例模式為一個面向對象的應用程序提供了對象惟一的訪問點，不管它實現何種功能，整個應用程序都會同享一個實例對象。

對于單例模式的幾種實現方式，知道餓漢式和懶漢式的區別，線程安全，資源加載的時機，還有懶漢式為了實現線程安全的3種方式的細微差別。

?

總結

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

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