1.單例設計模式核心作用：

保證一個類只有一個實例，并且提供了訪問該實例的全局訪問點

2.常見應用場景：

• window的任務管理器
• 項目中讀取配置文件一般也是一個單例模式
• 數據庫連接池的設計也是采用單例模式，因為數據庫連接是一種數據庫資源
• 操作系統的文件管理系統，也是單例模式，一個操作系統只能有一個文件系統
• Application也是單例的應用（Servlet編程或者Android的Application類）
• 在Spring中，每個bean默認也是單例的，這樣的有點兒事Spring容器可以管理
• 在Servlet編程中每個Servlet也是單例的
• 在Spring MVC和Struts1框架中控制器對象也是單例

3.單例模式的優點

• 由于單例模式只生產一個對象，減少了系統開銷，當一個對象的產生需要的資源比較多的時候，比如讀取配置文件、產生其它依賴對象時，則可以在應用啟動的時候直接產生一個單例對象，然后永久駐存內存的方式來解決。
• 單例模式可以在系統設置全局訪問點，優化共享資源的訪問。例如可以設計一個單例類，負責所有數據表的映射。

4.常見5中單例模式的實現方式：

主要

餓漢式：線程安全，調用效率高。但是不能延時加載

懶漢式：線程安全，調用效率不高。但是可以延遲加載

其它：

雙重檢鎖式：由于JVM底層內部模型的原因，偶爾會出現問題，不建議使用

靜態內部類式：線程安全，調用效率高，而且可以延遲加載

枚舉單例：線程安全，調用效率高，不可延遲加載

餓漢式的示例代碼：

public class Singleton01 {//類初始化的時候，立即加載這個對象（沒有延時加載的優勢）。加載類時，是線程安全的private static Singleton01 instance = new Singleton01();private Singleton01(){}//方法沒有同步調用效率高public static Singleton01 getInstance(){return instance;} }

?

餓漢式單例模式的代碼中，static變量會在類裝載的時候進行初始化，此時不會涉及到多個線程對象訪問該對象的問題。虛擬機會保證只會裝載一次該類，肯定不會發生并發訪問的問題，因此可以省略synchronized關鍵字

問題：如果僅僅是加載本類，而不是要調用getInstance，甚至永遠都沒有調用，則會造成資源浪費。

懶漢式的示例代碼

1 package com.chunjiangchao.pattern.singleton; 2 /** 3 * 測試懶漢式單例模式 4 */ 5 public class Singleton02 { 6 //類初始化的時候，不初始化這個對象（延時加載，真正用的時候再創建）。 7 private static Singleton02 instance = null; 8 private Singleton02(){} 9 方法同步，調用效率低！ 10 public static synchronized Singleton02 getInstance(){ 11 if(instance == null) 12 instance = new Singleton02(); 13 return instance; 14 } 15 }

?

要點：延遲加載，懶加載真正用到的時候才會選擇加載

問題：

資源利用率高了，但是每次調用getInstance()方法都要同步，并發效率較低。

雙重檢鎖實現

1 package com.chunjiangchao.pattern.singleton; 2 /** 3 * 測試DCL（雙重檢鎖）單例模式 4 * 5 */ 6 public class Singleton03 { 7 //類初始化的時候，不初始化這個對象（延時加載，真正用的時候再創建）。 8 private volatile static Singleton03 instance = null; 9 private Singleton03(){} 10 代碼塊同步，調用效率要比同步方法要快一些，由于JVM的原因在高并發的情況下會出現問題 11 public static Singleton03 getInstance(){ 12 if(instance == null){ 13 synchronized (Singleton03.class) { 14 if(instance == null) 15 instance = new Singleton03(); 16 } 17 } 18 return instance; 19 } 20 }

?Volatile關鍵字的作用：

• 防止指令重排序如：instance = new Singleton03();這條操作分三步執行，1、分配內存；2、進行初始化；3、將生成對象的堆內存地址賦值給instance變量。這些指令中2、 3的位置可能會進行重排序，導致在獲取到對象的時候，該對象還沒有進行初始化。volatitle可以防止這種指令進行重排序。
• 當然Volatile還有一個作用是同步CPU緩存區和內存中的變量

提高了執行 的效率，不必每次獲取對象的時候都要進行同步，只有第一次才會進行同步創建。

問題：

由于編譯器優化的原因和JVM底層內部模型原因，偶爾會出現問題，不建議使用。但是我們可以在instance前面添加volatile關鍵字，這樣就沒問題了。

靜態內部類實現方式：（懶加載方式）

1 package com.chunjiangchao.pattern.singleton; 2 /** 3 * 靜態內部類單例模式 4 * 這種方式：線程安全，調用效率高，并且實現了延時加載！ 5 */ 6 public class Singleton04 { 7 private Singleton04(){} 8 public static Singleton04 getInstance(){ 9 return Inner.instance; 10 } 11 private static class Inner{ 12 private static final Singleton04 instance = new Singleton04(); 13 } 14 }

?

外部類沒有static屬性，則不會像餓漢式那樣，上來就把對象造出來了

只有真正調用getInstance才會加載靜態內部類。加載類時是線程安全的。instance 是static final類型，保證了內存中只有這樣一個實例存在，而且只被賦值一次，從而保證了線程安全性。

兼并并發高效調用和延遲加載的優勢。

換一句戶說：靜態內部有具備餓漢式和延遲加載的優勢。

枚舉實現單例：

1 package com.chunjiangchao.pattern.singleton; 2 /** 3 * 枚舉式實現單例模式(沒有延時加載) 4 */ 5 public enum Singleton05 { 6 instance;//這個枚舉元素，本身就是單例對象！ 7 public void operation(){ 8 //添加需要的操作 9 } 10 }

?

優點：實現簡單；枚舉本身就是單例。由JVM從根本上提供保障。避免反射和序列化的漏洞

缺點：無延遲加載

5.如何選用這五種單例模式？

單例對象占用資源少，不需要延遲加載：

枚舉好于餓漢式

單例對象占用資源大，需要延遲加載

靜態內部類好于懶漢式

6.問題

反射可以破解上面（不包含枚舉）的實現方式（防止的做法是在構造方法中手動拋出異常）

反序列化可以破解（不包含枚舉）的實現方式

可以通過定義readResolve防止獲得不同對象。反序列化的時候，如果對象所在的類定義了readResolve()方法（一種回調方法），返回自己創建的那個對象。

示例代碼如下：

?

1 package com.bjsxt.singleton; 2 3 import java.io.ObjectStreamException; 4 import java.io.Serializable; 5 6 /** 7 * 測試懶漢式單例模式(如何防止反射和反序列化漏洞) 8 * 9 */ 10 public class SingletonDemo6 implements Serializable { 11 //類初始化時，不初始化這個對象（延時加載，真正用的時候再創建）。 12 private static SingletonDemo6 instance; 13 14 private SingletonDemo6(){ //私有化構造器 15 if(instance!=null){ 16 throw new RuntimeException(); 17 } 18 } 19 20 //方法同步，調用效率低！ 21 public static synchronized SingletonDemo6 getInstance(){ 22 if(instance==null){ 23 instance = new SingletonDemo6(); 24 } 25 return instance; 26 } 27 28 //反序列化時，如果定義了readResolve()則直接返回此方法指定的對象。而不需要單獨再創建新對象！ 29 private Object readResolve() throws ObjectStreamException { 30 return instance; 31 } 32 33 }

?測試代碼如下：

1 package com.chunjiangchao.pattern.singleton; 2 3 import java.io.FileInputStream; 4 import java.io.FileNotFoundException; 5 import java.io.FileOutputStream; 6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 import java.lang.reflect.Constructor; 9 10 /** 11 * 測試單例模式 12 */ 13 public class SingletonDemo { 14 public static void main(String[] args) throws Exception { 15 Singleton01 singleton01 = Singleton01.getInstance(); 16 Singleton01 singleton02 = Singleton01.getInstance(); 17 System.out.println(singleton01.hashCode()); 18 System.out.println(singleton02.hashCode()); 19 20 /** 21 //測試反射 22 try { 23 Class<?> clazz = Class.forName("com.chunjiangchao.pattern.singleton.Singleton06"); 24 Constructor<?> constructor = clazz.getDeclaredConstructor(null); 25 constructor.setAccessible(true); 26 Singleton06 singleton06 = (Singleton06) constructor.newInstance(null); 27 System.out.println(singleton06); 28 System.out.println(Singleton06.getInstance()); 29 } catch (Exception e) { 30 e.printStackTrace(); 31 } 32 //打印的結果： 33 //com.chunjiangchao.pattern.singleton.Singleton06@495c83b2 34 //com.chunjiangchao.pattern.singleton.Singleton06@58ca40be 35 */ 36 //通過序列化獲取一個對象 37 Singleton06 instance = Singleton06.getInstance(); 38 FileOutputStream fos = new FileOutputStream("/Users/xxx/Desktop/a.txt"); 39 ObjectOutputStream oos = new ObjectOutputStream(fos); 40 oos.writeObject(instance); 41 oos.close(); 42 fos.close(); 43 44 FileInputStream fis = new FileInputStream("/Users/xxx/Desktop/a.txt"); 45 ObjectInputStream ois = new ObjectInputStream(fis); 46 Object obj = ois.readObject(); 47 ois.close(); 48 fis.close(); 49 System.out.println(instance); 50 System.out.println(obj); 51 } 52 53 }

?7、測試幾種模式的效率

五種單例模式在多線程環境下效率測試：使用CountDownLatch同步工具類，允許當前線程等待其它一組線程都執行完畢后，執行當前線程的后續操作。

countDown()當前線程執行此方法，計數器-1

await()調動此方法會一直阻塞當前線程，知道計數器為0的時候重新運行當前線程

下面示例代碼來演示當前線程執行的效率：

1 package com.chunjiangchao.pattern.singleton; 2 3 import java.util.concurrent.CountDownLatch; 4 5 /** 6 * 五種單例模式的性能測試 7 * 8 */ 9 public class SingletonDemo02 { 10 11 public static void main(String[] args) throws InterruptedException { 12 int threadNum = 10; 13 long beginTime = System.currentTimeMillis(); 14 final CountDownLatch countDownLatch = new CountDownLatch(threadNum); 15 for (int i = 0; i < threadNum; i++) { 16 new Thread(new Runnable() { 17 18 @Override 19 public void run() { 20 for (int j = 0; j < 20000; j++) { 21 //Singleton01.getInstance();//18ms 22 //Singleton02.getInstance();//49ms 23 //Singleton03.getInstance();//22ms 24 //Singleton04.getInstance();//32ms 25 Singleton05 instance = Singleton05.instance;//9ms 26 } 27 countDownLatch.countDown(); 28 } 29 }).start(); 30 } 31 //讓主線程進行阻塞 32 countDownLatch.await(); 33 long endTime = System.currentTimeMillis(); 34 System.out.println(endTime-beginTime); 35 } 36 37 }

單例對象占用資源少，不需要延遲加載：

轉載于:https://www.cnblogs.com/chun-jiang-chao-de-gu-shi/p/5376574.html

總結

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

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