設計模式（十四）單例模式(建立型)

懶漢，線程不安全

public class Singleton {  
     private static Singleton instance;  
     private Singleton (){}   
     public static Singleton getInstance() {  
     if (instance == null) {  
         instance = new Singleton();  
     }  
     return instance;  
     }  
}

懶漢，線程安全

public class Singleton {  
     private static Singleton instance;  
     private Singleton (){}
     public static synchronized Singleton getInstance() {  
     if (instance == null) {  
         instance = new Singleton();  
     }  
     return instance;  
     }  
}

餓漢

public class Singleton {  
     private static Singleton instance = new Singleton();  
     private Singleton (){}
     public static Singleton getInstance() {  
           return instance;  
     }  
}

這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，雖然致使類裝載的緣由有不少種，在單例模式中大多數都是調用getInstance方法， 可是也不能肯定有其餘的方式（或者其餘的靜態方法）致使類裝載，這時候初始化instance顯然沒有達到lazy loading的效果。

餓漢，變種

public class Singleton {  
     private Singleton instance = null;  
     static {  
         instance = new Singleton();  
     }  
     private Singleton (){}
     public static Singleton getInstance() {  
          return this.instance;  
     }  
}

靜態內部類

public class Singleton {  
     private static class SingletonHolder {  
          private static final Singleton INSTANCE = new Singleton();  
     }  
     private Singleton (){}
     public static final Singleton getInstance() {  
           return SingletonHolder.INSTANCE;  
     }  
}

這種方式一樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不一樣的是（很細微的差異）：第三種和第四種方式是隻要Singleton類被裝載了，那麼instance就會被實例化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不必定被初始化。由於SingletonHolder類沒有被主動使用，只有顯示經過調用getInstance方法時，纔會顯示裝載SingletonHolder類，從而實例化instance。想象一下，若是實例化instance很消耗資源，我想讓他延遲加載，另一方面，我不但願在Singleton類加載時就實例化，由於我不能確保Singleton類還可能在其餘的地方被主動使用從而被加載，那麼這個時候實例化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方式就顯得很合理。

枚舉

public enum Singleton {  
     INSTANCE;  
     public void whateverMethod() {  
     }  
}

這種方式是Effective Java做者Josh Bloch 提倡的方式，它不只能避免多線程同步問題，並且還能防止反序列化從新建立新的對象，可謂是很堅強的壁壘啊，不過，我的認爲因爲1.5中才加入enum特性，用這種方式寫難免讓人感受生疏，在實際工做中，我也不多看見有人這麼寫過。

雙重校驗鎖

public class Singleton {  
     private volatile static Singleton singleton;  
     private Singleton (){}   
     public static Singleton getSingleton() {  
     if (singleton == null) {  
         synchronized (Singleton.class) {  
             if (singleton == null) {  
                 singleton = new Singleton();  
             }  
         }  
     }  
     return singleton;  
     }  
}

總結

有兩個問題須要注意：

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

     二、若是Singleton實現了java.io.Serializable接口，那麼這個類的實例就可能被序列化和復原。無論怎樣，若是你序列化一個單例類的對象，接下來複原多個那個對象，那你就會有多個單例類的實例。

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

private static Class getClass(String classname)  throws ClassNotFoundException {     
       ClassLoader classLoader = Thread.currentThread().getContextClassLoader();     
       
       if(classLoader == null)     
          classLoader = Singleton.class.getClassLoader();     
      
       return (classLoader.loadClass(classname));          
}

對第二個問題修復的辦法是：

public class Singleton implements java.io.Serializable {     
    public static Singleton INSTANCE = new Singleton();     
       
    protected Singleton() {     
         
    }     
    private Object readResolve() {     
             return INSTANCE;     
    }    
}

我是天王蓋地虎的分割線

 

 

參考：http://cantellow.javaeye.com/blog/838473