設計模式-單例模式（Singleton Pattern）

一、介紹：

　　　單例模式（Singleton Pattern）： 所謂單例，就是整個程序有且僅有一個實例。該類負責建立本身的對象，同時確保只有一個對象被建立。

           場景： 頻繁建立對象、管理對象是一件耗費資源的事，可使用單例模式。

二、特色

• 類構造器私有
• 持有本身類型的屬性
• 對外提供獲取實例的靜態方法

三、實現方式

　編寫單例模式的代碼其實很簡單，就分了三步：

• 將構造函數私有化（禁止 new 對象）
• 在類的內部建立實例
• 提供獲取惟一實例的方法

 

 

第一種（懶漢，線程不安全）：

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; } } 

 

這種寫法可以在多線程中很好的工做，並且看起來它也具有很好的lazy loading，可是，遺憾的是，效率很低，99%狀況下不須要同步。

第三種（餓漢）：

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

 

這種方式基於classloder機制，在深度分析Java的ClassLoader機制（源碼級別）和Java類的加載、連接和初始化兩個文章中有關於CLassload而機制的線程安全問題的介紹，避免了多線程的同步問題，不過，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; } } 

 

表面上看起來差異挺大，其實更第三種方式差很少，都是在類初始化即實例化instance。

第五種（靜態內部類 ，推薦寫法）：

高效

 

原理：
當任何一個線程第一次調用 getInstance()時，都會使 SingletonHolder 被加載和被初始化，此時靜態初始化器將執行Singleton的初始化操做。(被調用時才進行初始化)

 

初始化靜態數據時，Java 提供了的線程安全性保證(因此不須要任何的同步)

 

 

Demo1

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

 

Demo2  --- 高效

 

public class Krryblog {

  private Krryblog() {}

  // 使用內部類的方式來實現懶加載
  private static class LazyHolder {
    // 建立單例對象
    private static final Krryblog INSTANCE = new Krryblog();
  }

  // 獲取對象
  public static final Krryblog getInstance() {
    return LazyHolder.INSTANCE;
  }
  
}

 

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

第六種（枚舉）： 

最安全、簡潔寫法，推薦寫法

 

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

 

Demo 

public enum Krryblog {

  INSTANCE,

  private Resource resource;
  
  // 建立單例對象
  public Krryblog () {
    resource = new Resource();
  }

  // 獲取單例對象
  public Resource getInstance() {
    return resource;
  }
}

Test

public class TestPattern {
 
  public static void main(String[] args) {
      Resource instance = Krryblog.INSTANCE.getInstance();
  }
}

 

這種方式是Effective Java做者Josh Bloch 提倡的方式，它不只能避免多線程同步問題，並且還能防止反序列化從新建立新的對象，可謂是很堅強的壁壘啊，在深度分析Java的枚舉類型----枚舉的線程安全性及序列化問題中有詳細介紹枚舉的線程安全問題和序列化問題，不過，我的認爲因爲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; } } 

總結

有兩個問題須要注意：

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

2.若是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; } }