Java中單例設計模式，餓漢式和懶漢式

　　Java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裏主要介紹三種：懶漢式單例、餓漢式單例、登記式單例。
　　單例模式有如下特色：
　　一、單例類只能有一個實例。
　　二、單例類必須本身建立本身的惟一實例。
　　三、單例類必須給全部其餘對象提供這一實例。
　　單例模式確保某個類只有一個實例，並且自行實例化並向整個系統提供這個實例。在計算機系統中，線程池、緩存、日誌對象、對話框、打印機、顯卡的驅動程序對象常被設計成單例。這些應用都或多或少具備資源管理器的功能。每臺計算機能夠有若干個打印機，但只能有一個Printer Spooler，以免兩個打印做業同時輸出到打印機中。每臺計算機能夠有若干通訊端口，系統應當集中管理這些通訊端口，以免一個通訊端口同時被兩個請求同時調用。總之，選擇單例模式就是爲了不不一致狀態，避免政出多頭。java

1、懶漢式單例（面試常問）

 1 //懶漢式單例類.在第一次調用的時候實例化本身 
 2 public class Singleton {  3     private Singleton() {}  4     private static Singleton single=null;  5     //靜態工廠方法 
 6     public static Singleton getInstance() {  7          if (single == null) {  8              single = new Singleton();  9  } 10         return single; 11  } 12 }

　　Singleton經過將構造方法限定爲private避免了類在外部被實例化，在同一個虛擬機範圍內，Singleton的惟一實例只能經過getInstance()方法訪問。面試

　　（事實上，經過Java反射機制是可以實例化構造方法爲private的類的，那基本上會使全部的Java單例實現失效。此問題在此處不作討論，姑且掩耳盜鈴地認爲反射機制不存在。）設計模式

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

一、在getInstance方法上加同步（性能較差）安全

1 public static synchronized Singleton getInstance() { 2          if (single == null) { 3              single = new Singleton(); 4  } 5         return single; 6 }

二、雙重檢查鎖定（DCL 雙檢查鎖機制）推薦多線程

 1 public static Singleton getInstance() {  2         if (singleton == null) {  3             synchronized (Singleton.class) {  4                if (singleton == null) {  5                   singleton = new Singleton();  6  }  7  }  8  }  9         return singleton; 10     }

三、靜態內部類推薦併發

1 public class Singleton { 2     private static class LazyHolder { 3        private static final Singleton INSTANCE = new Singleton(); 4  } 5     private Singleton (){} 6     public static final Singleton getInstance() { 7        return LazyHolder.INSTANCE; 8  } 9 }

　　這種比上面一、2都好一些，既實現了線程安全，又避免了同步帶來的性能影響。性能

2、餓漢式單例（用的多）

1 //餓漢式單例類.在類初始化時，已經自行實例化 
2 public class Singleton1 { 3     private Singleton1() {} 4     private static final Singleton1 single = new Singleton1(); 5     //靜態工廠方法 
6     public static Singleton1 getInstance() { 7         return single; 8  } 9 }

　　餓漢式在類建立的同時就已經建立好一個靜態的對象供系統使用，之後再也不改變，因此天生是線程安全的。測試

3、登記式單例(可忽略)

 1 package singleton;  2 
 3 import java.util.HashMap;  4 import java.util.Map;  5 
 6 /**
 7  * @author zsh  8  * @company wlgzs  9  * @create 2019-03-02 10:49 10  * @Describe 登記式單例 11  * 相似String裏面的方法，將類名註冊，下次從裏面直接獲取 12  */
13 public class Main3 { 14     private static Map<String,Main3> map = new HashMap<>(); 15     //初始數據
16     static { 17         Main3 main3 = new Main3(); 18  map.put(main3.getClass().getName(),main3); 19  } 20     protected Main3(){} 21     //靜態工廠方法，返還此類的惟一實例
22     public static Main3 getInstance(String name){ 23         if (name == null){ 24             name = Main3.class.getName(); 25             System.out.println("Name == null,"+"--> name =" + name); 26  } 27         if (map.get(name) == null){ 28             try { 29  map.put(name, (Main3) Class.forName(name).newInstance()); 30             } catch (InstantiationException e) { 31  e.printStackTrace(); 32             } catch (IllegalAccessException e) { 33  e.printStackTrace(); 34             } catch (ClassNotFoundException e) { 35  e.printStackTrace(); 36  } 37  } 38         return map.get(name); 39  } 40 
41     public String print(){ 42         return "Hello"; 43  } 44 
45     public static void main(String[] args) { 46         Main3 instance = Main3.getInstance(null); 47  System.out.println(instance.print()); 48  } 49 }

運行結果：this

　　登記式單例實際上維護了一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從Map直接返回，對於沒有登記的，則先登記，而後返回。

　　這裏我對登記式單例標記了可忽略，個人理解來講，首先它用的比較少，另外其實內部實現仍是用的餓漢式單例，由於其中的static方法塊，它的單例在類被裝載的時候就被實例化了。

4、餓漢式和懶漢式區別

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

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

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

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

　　一、線程安全：

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

　　懶漢式自己是非線程安全的，爲了實現線程安全有幾種寫法，分別是上面的一、二、3，這三種實如今資源加載和性能方面有些區別。

　　二、資源加載和性能：

　　餓漢式在類建立的同時就實例化一個靜態對象出來，無論以後會不會使用這個單例，都會佔據必定的內存，可是相應的，在第一次調用時速度也會更快，由於其資源已經初始化完成，

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

　　至於一、二、3這三種實現又有些區別，

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

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

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

　　什麼是線程安全？

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

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

5、應用

　　如下是一個單例類使用的例子，以懶漢式爲例，這裏爲了保證線程安全，使用了雙重檢查鎖定的方式：

 1 package singleton;  2 
 3 /**
 4  * @author zsh  5  * @company wlgzs  6  * @create 2019-03-02 11:01  7  * @Describe 單例設計模式測試  8  */
 9 public class Main4 { 10     String name = null; 11     private Main4(){} 12 
13     private static volatile Main4 instance = null; 14 
15     public static Main4 getInstance(){ 16         if (instance == null){ 17             synchronized (Main1.class){ 18                 if (instance == null){ 19                     instance = new Main4(); 20  } 21  } 22  } 23         return instance; 24  } 25 
26     public String getName() { 27         return name; 28  } 29 
30     public void setName(String name) { 31         this.name = name; 32  } 33 
34     public void printInfo(){ 35         System.out.println("這個實例的名字爲"+name); 36  } 37 }

　　能夠看到裏面加了volatile關鍵字來聲明單例對象，既然synchronized已經起到了多線程下原子性、有序性、可見性的做用，爲何還要加volatile呢，緣由已經在下面評論中提到，見個人另外一篇博客：

 1 package singleton;  2 
 3 /**
 4  * @author zsh  5  * @company wlgzs  6  * @create 2019-03-02 11:05  7  * @Describe 單例設計模式測試主類  8  */
 9 public class Main5 { 10     public static void main(String[] args) { 11         Main4 main4 = Main4.getInstance(); 12         main4.setName("123"); 13         Main4 main41 = Main4.getInstance(); 14         main41.setName("456"); 15 
16  main4.printInfo(); 17  main41.printInfo(); 18 
19         if (main4 == main41){ 20             System.out.println("建立的是同一個實例"); 21         }else { 22             System.out.println("建立的不是同一個實例"); 23  } 24  } 25 }

運行結果：

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

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