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


一、懶漢式單例
Java代碼 

1. //懶漢式單例類.在第一次調(diào)用的時(shí)候?qū)嵗约?nbsp;    
2. public class Singleton {    
3.     //私有的默認(rèn)構(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避免了類在外部被實(shí)例化，在同一個(gè)虛擬機(jī)范圍內(nèi)，Singleton的唯一實(shí)例只能通過getInstance()方法訪問。
（事實(shí)上，通過Java反射機(jī)制是能夠?qū)嵗瘶?gòu)造方法為private的類的，那基本上會(huì)使所有的Java單例實(shí)現(xiàn)失效。此問題在此處不做討論，姑且掩耳盜鈴地認(rèn)為反射機(jī)制不存在。）

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



二、餓漢式單例
Java代碼 

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

餓漢式在類創(chuàng)建的同時(shí)就已經(jīng)創(chuàng)建好一個(gè)靜態(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.     //保護(hù)的默認(rèn)構(gòu)造子    
9.     protected Singleton3(){}    
10.     //靜態(tài)工廠方法,返還此類惟一的實(shí)例    
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.     //一個(gè)示意性的商業(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. }    

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



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

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

1、線程安全：

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

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

2、資源加載：

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

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



什么是線程安全？

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

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



應(yīng)用

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


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)建的是同一個(gè)實(shí)例");    
13.         }else{    
14.             System.out.println("創(chuàng)建的不是同一個(gè)實(shí)例");    
15.         }    
16.     }    
17. }