詳解三種單例模式的實現

培育能力的事必須繼續不斷地去作，又必須隨時改善學習方法，提升學習效率，纔會成功。

單例模式的定義：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點！

懶漢

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機制避免了多線程的同步問題，instance在類裝載時就實例化。目前java單例是指一個虛擬機的範圍，由於裝載類的功能是虛擬機的，因此一個虛擬機在經過本身的ClassLoader裝載餓漢式實現單例類的時候就會建立一個類的實例。

這就意味着一個虛擬機裏面有不少ClassLoader，而這些Classloader都能裝載某個類的話，就算這個類是單例，也能產生不少實例。固然若是一臺機器上有不少虛擬機，那麼每一個虛擬機中都有至少一個這個類的實例的話，那這樣就更不會是單例了。(這裏討論的單例不適合集羣！)

靜態內部類

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不必定被初始化。由於SingletonHolder類沒有被主動使用，只有顯示經過調用getInstance方法時，纔會顯示裝載SingletonHolder類，從而實例化instance。

想象一下，若是實例化instance很消耗資源，我想讓他延遲加載！這個時候，這種方式相比第2種方式就顯得很合理。

枚舉

public enum Singleton {
    INSTANCE;

    public void whateverMethod() {
    }
}

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

雙重校驗鎖(jdk1.5)

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

這樣方式實現線程安全地建立實例，而又不會對性能形成太大影響。它只是第一次建立實例的時候同步，之後就不須要同步了。

因爲volatile關鍵字屏蔽了虛擬機中一些必要的代碼優化，因此運行效率並非很高，所以建議沒有特別的須要不要使用。雙重檢驗鎖方式的單例不建議大量使用，根據狀況決定。

總結

有兩個問題須要注意：

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