Java 單例模式的七種寫法__Java

第一種（懶漢，線程不安全）：
public   class  Singleton {  
 2       private   static  Singleton instance;  
 3      private Singleton (){}   
 4       public   static  Singleton getInstance() {  
 5       if  (instance  ==   null ) {  
 6          instance  =   new  Singleton();  
 7      }  
 8       return  instance;  
 9      }  
10  }  
11 

這種寫法lazy loading很明顯，但是致命的是在多線程不能正常工作。

第二種（懶漢，安全執行緒）：

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

這種寫法能夠在多線程中很好的工作，而且看起來它也具備很好的lazy loading，但是，遺憾的是，效率很低，99%情況下不需要同步。

第三種（餓漢）：

1  public   class  Singleton {  
2       private   static  Singleton instance  =   new  Singleton();  
3      private Singleton (){}
4       public   static  Singleton getInstance() {  
5       return  instance;  
6      }  
7  }  
8 

這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就執行個體化，雖然導致類裝載的原因有很多種，在單例模式中大多數都是調用getInstance方法， 但是也不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候初始化instance顯然沒有達到lazy loading的效果。

第四種（餓漢，變種）：

 1  public   class  Singleton {  
 2       private  Singleton instance  =   null ;  
 3       static  {  
 4      instance  =   new  Singleton();  
 5      }  
 6      private Singleton (){}
 7       public   static  Singleton getInstance() {  
 8       return   this .instance;  
 9      }  
10  }  
11 

表面上看起來差別挺大，其實更第三種方式差不多，都是在類初始化即執行個體化instance。

第五種（靜態內部類）：
 1  public   class  Singleton {  
 2       private   static   class  SingletonHolder {  
 3       private   static   final  Singleton INSTANCE  =   new  Singleton();  
 4      }  
 5      private Singleton (){}
 6       public   static   final  Singleton getInstance() {  
 7           return  SingletonHolder.INSTANCE;  
 8      }  
 9  }  
10 

 

這種方式同樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不同的是（很細微的差別）：第三種和第四種方式是只要Singleton類被裝載了，那麼instance就會被執行個體化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因為SingletonHolder類沒有被主動使用，只有顯示通過調用getInstance方法時，才會顯示裝載SingletonHolder類，從而執行個體化instance。想象一下，如果執行個體化instance很消耗資源，我想讓他消極式載入，另外一方面，我不希望在Singleton類載入時就執行個體化，因為我不能確保Singleton類還可能在其他的地方被主動使用從而被載入，那麼這個時候執行個體化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方式就顯得很合理。

第六種（枚舉）： 1  public   enum  Singleton {  
2      INSTANCE;  
3       public   void  whateverMethod() {  
4      }  
5  }  
6 

這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止還原序列化重新建立新的對象，可謂是很堅強的壁壘啊，不過，個人認為由於1.5中才加入enum特性，用這種方式寫不免讓人感覺生疏，在實際工作中，我也很少看見有人這麼寫過。
 

第七種（雙重校正鎖）：

 1  public   class  Singleton {  
 2       private   volatile   static  Singleton singleton;  
 3      private Singleton (){}   
 4       public   static  Singleton getSingleton() {  
 5       if  (singleton  ==   null ) {  
 6           synchronized  (Singleton. class ) {  
 7           if  (singleton  ==   null ) {  
 8              singleton  =   new  Singleton();  
 9          }  
10          }  
11      }  
12       return  singleton;  
13      }  
14  }  
15 

這個是第二種方式的升級版，俗稱雙重檢查鎖定，詳細介紹請查看：http://www.ibm.com/developerworks/cn/java/j-dcl.html

在JDK1.5之後，雙重檢查鎖定才能夠正常達到單例效果。

總結

有兩個問題需要注意：

     1、如果單例由不同的類裝載器裝入，那便有可能存在多個單例類的執行個體。假定不是遠端存取，例如一些servlet容器對每個servlet使用完全不同的類  裝載器，這樣的話如果有兩個servlet訪問一個單例類，它們就都會有各自的執行個體。

     2、如果Singleton實現了java.io.Serializable介面，那麼這個類的執行個體就可能被序列化和複原。不管怎樣，如果你序列化一個單例類的對象，接下來複原多個那個對象，那你就會有多個單例類的執行個體。

對第一個問題修複的辦法是：

 1  private   static  Class getClass(String classname)      
 2                                            throws  ClassNotFoundException {     
 3        ClassLoader classLoader  =  Thread.currentThread().getContextClassLoader();     
 4        
 5         if (classLoader  ==   null )     
 6           classLoader