簡潔全面的單例模式整理

單例實現

保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。

1.靜態內部類

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

    private Singleton() {
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

2.餓漢模式

通過定義靜態的成員變量，以保證單例對象可以在類初始化的過程中被實例化。
這其實是利用了ClassLoader的線程安全機制。ClassLoader的loadClass方法在加載類的時候使用了synchronized關鍵字。
所以， 除非被重寫，這個方法默認在整個裝載過程中都是線程安全的。所以在類加載過程中對象的創建也是線程安全的。

public class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

3.懶漢模式

雙重校驗鎖方式實現單例。

爲什麼用volatile修飾？

因爲編譯器有可能進行指令重排優化，使得singleton對象再未完成初始化之前就對其進行了賦值，這樣其他人拿到的對象就可能是個殘缺的對象了。使用volatile的目的是避免指令重排。保證先進性初始化，然後進行賦值

public class Singleton {

    private static volatile Singleton instance;

    private Singleton() {}

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

}

4.枚舉實現

枚舉底層依賴Enum類實現的，這個類的成員變量都是static類型的，並且在靜態代碼塊中實例化，保證線程安全。

枚舉可以解決反序列化破壞單例的問題。

在枚舉序列化的時候，Java僅僅是將枚舉對象的name屬性輸出到結果中，反序列化的時候則是通過java.lang.Enum的valueOf方法來根據名字查找枚舉對象。同時，編譯器是不允許任何對這種序列化機制的定製的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。
普通的Java類的反序列化過程中，會通過反射調用類的默認構造函數來初始化對象。所以，即使單例中構造函數是私有的，也會被反射給破壞掉。由於反序列化後的對象是重新new出來的，所以這就破壞了單例。
但是，枚舉的反序列化並不是通過反射實現的。所以，也就不會發生由於反序列化導致的單例破壞問題。

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

5.CAS實現

 private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();

    private Singleton() {}

    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }

            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }

單例破壞

反射破壞

private void distoryByReflect() {
    Singleton singleton = Singleton.getSingleton();
    try {
        Class<Singleton> singleClass = (Class<Singleton>)Class.forName("com.esparks.pandora.learning.designmode.Singleton");

        Constructor<Singleton> constructor = singleClass.getDeclaredConstructor(null);

        constructor.setAccessible(true);

        Singleton singletonByReflect = constructor.newInstance();

        System.out.println("singleton : " + singleton);
        System.out.println("singletonByReflect : " + singletonByReflect);
        System.out.println("singleton == singletonByReflect : " + (singleton == singletonByReflect));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

解決方式：在Singleton的構造函數中增加如下代碼

private Singleton() {
    if (singleton != null) {
        throw new RuntimeException("Singleton constructor is called... ");
    }
}

序列化破壞

通過先序列化再反序列化的方式，可獲取到一個新的單例對象，這就破壞了單例。

private void distoryBySerialize() {
    Singleton singleton = Singleton.getSingleton();

    //Write Obj to file
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(singleton);
        //Read Obj from file
        File file = new File("tempFile");

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Singleton singletonBySerialize = (Singleton)ois.readObject();
        //判斷是否是同一個對象

        System.out.println("singleton : " + singleton);
        System.out.println("singletonBySerialize : " + singletonBySerialize);
        System.out.println("singleton == singletonBySerialize : " + (singleton == singletonBySerialize));

    } catch (Exception e) {
        e.printStackTrace();
    }
}

解決方式：在Singleton中增加readResolve方法，並在該方法中指定要返回的對象的生成策略幾可以了。即序列化在Singleton類中增加以下代碼即可：

private Object readResolve() {
    return getSingleton();
}