學習筆記
場景：
一般，我們在寫程序或者開發系統的時候，會有這樣的需求：有些類只需要在整個系統中只能出現一個類的實例(避免了一個全局使用的類頻繁地創建與銷毀)；比如一個全局配置信息類、或者一個Factory類，或是一個主控類，等等。這個時候就需要用到單例的設計模式
單例模式特點：
1、實例是全局的(因為這個原因，所以要考慮到多線程的共享全局資源的問題；因為是全局性的實例，所以，在多線程情況下，所有的全局共享的東西都會變得非常的危險)
2、只有一個實例，且只能這個類自己創建對象，并提供一個訪問它的全局訪問點
3、私有構造器
單例模式： 主要目的是想在整個系統中只能出現一個類的實例，避免了一個全局使用的類頻繁地創建與銷毀；比如你的軟件的全局配置信息，或者是一個Factory，或是一個主控類，等等
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
優點：
1、Lazy加載初始化、實現延時加載
缺點：
1、線程不安全(多線程的情況下，可能會有多個進程同時通過 (singleton== null)的條件檢查，于是，多個實例就創建出來，并且很可能造成內存泄露問題)
綜上所述，不推薦在實際開發中使用懶漢式
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
另一種寫法：
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
synchronized(Singleton.class){
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
}
優點：
1、Lazy加載初始化、實現延時加載
2、線程安全缺點：
1、雖然線程安全，但是仍然創建了很多實例(創建很多實例與單例的思想相違背的；雖然我們的synchronized方法會幫助我們同步所有的線程，讓我們并行線程變成串行的一個一個去new，那不還是一樣的嗎？同樣會出現很多實例。注意理解這里會創建很多實例。注意，創建對象的動作只有一次，后面的動作全是讀取那個成員變量，這些讀取的動作不需要線程同步啊。這樣的作法感覺非常極端啊，為了一個初始化的創建動作，居然讓我們達上了所有的讀操作，嚴重影響后續的性能啊！)
2、效率很低，99% 情況下不需要同步綜上所述，多線程下，對性能和內存要求高的情況下，不推薦使用此模式
public class Singleton {
/**
* 注意此處使用的關鍵字 volatile，
* 被volatile修飾的變量的值，將不會被本地線程緩存，
* 所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。
*/
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、Lazy加載初始化、實現延時加載
2、線程安全
3、使用了關鍵字volatile綜上所述，多線程下，對性能和內存要求高，推薦使用此模式
使用 volatile 有兩個功用：
1）這個變量不會在多個線程中存在復本，直接從內存讀取。
2）這個關鍵字會禁止指令重排序優化。也就是說，在 volatile 變量的賦值操作后面會有一個內存屏障（生成的匯編代碼上），讀操作不會被重排序到內存屏障之前。
但是，這個事情僅在Java 1.5版后有用，1.5版之前用這個變量也有問題，因為老版本的Java的內存模型是有缺陷的。
public class Singleton {
// volatile可以換成final
private volatile static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
優點：
1、線程安全(基于 classloader 機制避免了多線程的同步問題)
2、因為單例的實例被聲明成 static 和 final 變量了，在第一次加載類到內存中時就會初始化，所以創建實例本身是線程安全的缺點：
1、沒有實現延時加載
2、但是，這種玩法的最大問題是——當這個類被加載的時候，new Singleton() 這句話就會被執行，就算是getInstance()沒有被調用，類也被初始化了。
于是，這個可能會與我們想要的行為不一樣，比如，我的類的構造函數中，有一些事可能需要依賴于別的類干的一些事（比如某個配置文件，或是某個被其它類創建的資源），我們希望他能在我第一次getInstance()時才被真正的創建。這樣，我們可以控制真正的類創建的時刻，而不是把類的創建委托給了類裝載器綜上所述，推薦使用
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
優點：
1、線程安全
2、Lazy加載初始化、實現延時加載描述：
這種方式能達到雙檢鎖方式一樣的功效，但實現更簡單。對靜態域使用延遲初始化，應使用這種方式而不是雙檢鎖方式。這種方式只適用于靜態域的情況，雙檢鎖方式可在實例域需要延遲初始化時使用。
這種方式同樣利用了 classloader 機制來保證初始化 instance 時只有一個線程，它跟第 3 種方式不同的是：第 3 種方式只要 Singleton 類被裝載了，那么 instance 就會被實例化（沒有達到 lazy loading 效果），而這種方式是 Singleton 類被裝載了，instance 不一定被初始化。因為 SingletonHolder 類沒有被主動使用，只有通過顯式調用 getInstance 方法時，才會顯式裝載 SingletonHolder 類，從而實例化 instance。想象一下，如果實例化 instance 很消耗資源，所以想讓它延遲加載，另外一方面，又不希望在 Singleton 類加載時就實例化，因為不能確保 Singleton 類還可能在其他的地方被主動使用從而被加載，那么這個時候實例化 instance 顯然是不合適的。這個時候，這種方式相比第 4 種方式(餓漢模式)就顯得很合理。上面這種方式，仍然使用JVM本身機制保證了線程安全問題；由于 SingletonHolder 是私有的，除了 getInstance() 之外沒有辦法訪問它，因此它只有在getInstance()被調用時才會真正創建；同時讀取實例的時候不會進行同步，沒有性能缺陷；也不依賴 JDK 版本。
綜上所述，1.6版是老版《Effective Java》中推薦的方式
public enum Singleton {
INSTANCE;
public void method() {
}
}
優點：
1、線程安全
描述：
這種實現方式還沒有被廣泛采用，但這是實現單例模式的最佳方法。它更簡潔，自動支持序列化機制，絕對防止多次實例化。
這種方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還自動支持序列化機制，防止反序列化重新創建新的對象，絕對防止多次實例化。不過，由于 JDK1.5 之后才加入 enum 特性，用這種方式寫不免讓人感覺生疏，在實際工作中，也很少用。
不能通過 reflection attack 來調用私有構造方法。上面這種方式，仍然使用JVM本身機制保證了線程安全問題；由于 SingletonHolder 是私有的，除了 getInstance() 之外沒有辦法訪問它，因此它只有在getInstance()被調用時才會真正創建；同時讀取實例的時候不會進行同步，沒有性能缺陷；也不依賴 JDK 版本。
綜上所述，這也是新版的《Effective Java》中推薦的模式
public class SingletonManager {
private static Map<String, Object> objMap = new HashMap<String,Object>();
private Singleton() {}
public static void registerService(String key, Objectinstance) {
if (!objMap.containsKey(key) ) {
objMap.put(key, instance);
}
}
public static Object getService(String key) {
return objMap.get(key);
}
}
描述：
這種事用SingletonManager 將多種單例類統一管理，在使用時根據key獲取對象對應類型的對象。這種方式使得我們可以管理多種類型的單例，并且在使用時可以通過統一的接口進行獲取操作，降低了用戶的使用成本，也對用戶隱藏了具體實現，降低了耦合度。
單例模式有五種寫法：懶漢、餓漢、雙重檢驗鎖、靜態內部類、枚舉
經驗之談：一般情況下，不建議使用第 1 種和第 2 種懶漢方式，建議使用第 4 種餓漢方式。只有在要明確實現 lazy loading 效果時，才會使用第 5 種登記方式。如果涉及到反序列化創建對象時，可以嘗試使用第 6 種枚舉方式。如果有其他特殊的需求，可以考慮使用第 3 種雙檢鎖方式
