單例模式

　java中單例模式是一種常見的設(shè)計模式，單例模式分三種：懶漢式單例、餓漢式單例、登記式單例三種。
單例模式有以下特點：
1、單例類只能有一個實例。
2、單例類必須自己創(chuàng)建自己的唯一實例。
3、單例類必須給所有其他對象提供這一實例。
單例模式確保某個類只有一個實例，而且自行實例化并向整個系統(tǒng)提供這個實例。在計算機系統(tǒng)中，線程池、緩存、日志對象、對話框、打印機、顯卡 的驅(qū)動程序?qū)ο蟪１辉O(shè)計成單例。這些應(yīng)用都或多或少具有資源管理器的功能。每臺計算機可以有若干個打印機，但只能有一個Printer Spooler，以避免兩個打印作業(yè)同時輸出到打印機中。每臺計算機可以有若干通信端口，系統(tǒng)應(yīng)當集中管理這些通信端口，以避免一個通信端口同時被兩個請 求同時調(diào)用。總之，選擇單例模式就是為了避免不一致狀態(tài)，避免政出多頭。


一、懶漢式單例
Java代碼 

1. //懶漢式單例類.在第一次調(diào)用的時候?qū)嵗约?nbsp;    
2. public class Singleton {    
3.     //私有的默認構(gòu)造子    
4.     private Singleton() {}    
5.     //注意，這里沒有final        
6.     private static Singleton single=null;    
7.     //靜態(tài)工廠方法     
8.     public static Singleton getInstance() {    
9.          if (single == null) {      
10.              single = new Singleton();    
11.          }      
12.         return single;    
13.     }    
14. }    

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

但是以上懶漢式單例的實現(xiàn)沒有考慮線程安全問題，它是線程不安全的，并發(fā)環(huán)境下很可能出現(xiàn)多個Singleton實例，下面介紹的餓漢式單例是線程安全的。



二、餓漢式單例
Java代碼 

1. //餓漢式單例類.在類初始化時，已經(jīng)自行實例化     
2. public class Singleton1 {    
3.     //私有的默認構(gòu)造子    
4.     private Singleton1() {}    
5.     //已經(jīng)自行實例化     
6.     private static final Singleton1 single = new Singleton1();    
7.     //靜態(tài)工廠方法     
8.     public static Singleton1 getInstance() {    
9.         return single;    
10.     }    
11. }    

餓漢式在類創(chuàng)建的同時就已經(jīng)創(chuàng)建好一個靜態(tài)的對象供系統(tǒng)使用，以后不再改變，所以是線程安全的。


三、登記式單例
Java代碼 

1. //類似Spring里面的方法，將類名注冊，下次從里面直接獲取。    
2. public class Singleton3 {    
3.     private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();    
4.     static{    
5.         Singleton3 single = new Singleton3();    
6.         map.put(single.getClass().getName(), single);    
7.     }    
8.     //保護的默認構(gòu)造子    
9.     protected Singleton3(){}    
10.     //靜態(tài)工廠方法,返還此類惟一的實例    
11.     public static Singleton3 getInstance(String name) {    
12.         if(name == null) {    
13.             name = Singleton3.class.getName();    
14.             System.out.println("name == null"+"--->name="+name);    
15.         }    
16.         if(map.get(name) == null) {    
17.             try {    
18.                 map.put(name, (Singleton3) Class.forName(name).newInstance());    
19.             } catch (InstantiationException e) {    
20.                 e.printStackTrace();    
21.             } catch (IllegalAccessException e) {    
22.                 e.printStackTrace();    
23.             } catch (ClassNotFoundException e) {    
24.                 e.printStackTrace();    
25.             }    
26.         }    
27.         return map.get(name);    
28.     }    
29.     //一個示意性的商業(yè)方法    
30.     public String about() {        
31.         return "Hello, I am RegSingleton.";        
32.     }        
33.     public static void main(String[] args) {    
34.         Singleton3 single3 = Singleton3.getInstance(null);    
35.         System.out.println(single3.about());    
36.     }    
37. }    

登記式單例實際上維護了一組單例類的實例，將這些實例存放在一個Map（登記?。┲?，對于已經(jīng)登記過的實例，則從Map直接返回，對于沒有登記的，則先登記，然后返回。



餓漢式和懶漢式區(qū)別

這兩種乍看上去非常相似，其實是有區(qū)別的，主要兩點

1、線程安全：

餓漢式是線程安全的，可以直接用于多線程而不會出現(xiàn)問題，懶漢式就不行，它是線程不安全的，如果用于多線程可能會被實例化多次，失去單例的作用。

如果要把懶漢式用于多線程，有兩種方式保證安全性，一種是在getInstance方法上加同步，另一種是在使用該單例方法前后加雙鎖。

2、資源加載：

餓漢式在類創(chuàng)建的同時就實例化一個靜態(tài)對象出來，不管之后會不會使用這個單例，會占據(jù)一定的內(nèi)存，相應(yīng)的在調(diào)用時速度也會更快，

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



什么是線程安全？

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

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



應(yīng)用

以下是一個單例類使用的例子，以懶漢式為例：


Java代碼 

1. public class TestSingleton {    
2.     String name = null;    
3.     
4.         private TestSingleton() {    
5.     }    
6.     
7.     private static TestSingleton ts = null;    
8.     
9.     public static TestSingleton getInstance() {    
10.         if (ts == null) {    
11.             ts = new TestSingleton();    
12.         }    
13.         return ts;    
14.     }    
15.     
16.     public String getName() {    
17.         return name;    
18.     }    
19.     
20.     public void setName(String name) {    
21.         this.name = name;    
22.     }    
23.     
24.     public void printInfo() {    
25.         System.out.println("the name is " + name);    
26.     }    
27.     
28. }    

 
Java代碼 

1. public class TMain {    
2.     public static void main(String[] args){    
3.         TestStream ts1 = TestSingleton.getInstance();    
4.         ts1.setName("jason");    
5.         TestStream ts2 = TestSingleton.getInstance();    
6.         ts2.setName("0539");    
7.             
8.         ts1.printInfo();    
9.         ts2.printInfo();    
10.             
11.         if(ts1 == ts2){    
12.             System.out.println("創(chuàng)建的是同一個實例");    
13.         }else{    
14.             System.out.println("創(chuàng)建的不是同一個實例");    
15.         }    
16.     }    
17. }