單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。是一種創建型設計模式。他的定義為：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。

單例模式一般體現在類聲明中，單例的類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

但是其實，單例并不是完完全全安全的，也是有可能被破壞的。

以下，是一次面試現場的還原，之所以會聊到這個話題，是因為面試官問了我很多關于單例模式的問題，我回答的還可以，之后面試官隨口問了一句"單例絕對安全嗎？"，緊接著發生了如下對話：

Q：單例模式絕對安全嗎？ 

A：（這個問題我知道，別想難倒我）不一定的，其實單例也是有可能被破壞的？

Q：哦？怎么說？ 

A：單例模式其實是對外隱藏了構造函數，保證用戶無法主動創建對象。但是實際上我們是有辦法可以破壞他的。

Q：那你知道有什么辦法可以破壞單例嗎？？

A：有一個比較簡單的方式，那就是反射。

反射破壞單例

我們先來一個比較常見的單例模式： 

import java.io.Serializable;  
/**  
 * 使用雙重校驗鎖方式實現單例  
 */  
public class Singleton implements Serializable{  
    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;  
    }  
} 

這個單例模式提供了一個private類型的構造函數，正常情況下，我們無法直接調用對象的私有方法。但是反射技術給我們提供了一個后門。

如下代碼，我們通過反射的方式獲取到Singleton的構造函數，設置其訪問權限，然后通過該方法創建一個新的對象： 

import java.lang.reflect.Constructor;  
public class SingletonTest {  
    public static void main(String[] args) {  
        Singleton singleton = Singleton.getSingleton();  
        try {  
            Class<Singleton> singleClass = (Class<Singleton>)Class.forName("com.dev.interview.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 : com.dev.interview.Singleton@55d56113  
singletonByReflect : com.dev.interview.Singleton@148080bb  
singleton == singletonByReflect : false 

如上，通過發射的方式即可獲取到一個新的單例對象，這就破壞了單例。

Q：那這種破壞單例的情況，有辦法避免嗎？

A：其實是可以的，只要我們在構造函數中加一些判斷就行了。

如下方式，我們在Singleton的構造函數中增加如下代碼： 

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

這樣，在通過反射調用構造方法的時候，就會拋出異常： 

Caused by: java.lang.RuntimeException: Singleton constructor is called... 

序列化破壞單例

Q：嗯嗯，挺不錯的，那我們換個問題吧。

A：（這部分面試官在猶豫問我什么問題，我主動提醒了他一句）其實，除了反射可以破壞單例，還有一種其他方式也可以的。

Q：嗯，那你就說說還有什么方式吧 

A：其實通過序列化+反序列化的方式也是可以破壞單例的。

如以下代碼，我們通過先將單例對象序列化后保存到臨時文件中，然后再從臨時文件中反序列化出來： 

public class SingletonTest {  
    public static void main(String[] args) {  
        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 : com.dev.interview.Singleton@617faa95  
singletonBySerialize : com.dev.interview.Singleton@5d76b067  
singleton == singletonBySerialize : false 

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

因為在對象反序列化的過程中，序列化會通過反射調用無參數的構造方法創建一個新的對象，所以，通過反序列化也能破壞單例。

Q：那這種破壞單例的情況，也同樣有辦法避免嗎？

A：當然也有了。只要修改下反序列化策略就好了。

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

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

Q：為什么增加readResolve就可以解決序列化破壞單例的問題了呢？

A：因為反序列化過程中，在反序列化執行過程中會執行到ObjectInputStream#readOrdinaryObject方法，這個方法會判斷對象是否包含readResolve方法，如果包含的話會直接調用這個方法獲得對象實例。

Q：那如果沒有readResolve方法的話，反序列化的時候會怎么創建對象呢？

A：當然也是反射咯。

Q：那前面不是說使用反射的情況，直接在構造函數拋異常不就行了嗎？

A：這個我還真試過，其實是不行的，反序列化使用的反射構造器和我們代碼中使用反射的構造器不是同一個，反序列化用到的構造器并不會調用到我們對象中的構造函數…balabala…（我也不知道面試官聽不聽得懂，感覺是沒聽懂…） 

Q：哦。OK吧，請問你什么時候可以來上班？

不久之后，我入職了這家公司，在一次和當初的面試官聊天的時候，他無意間和我說：當時我面試你的時候，關于單例的破壞那幾個問題，其實最開始我只是隨口一問，沒想到你給我吹水了20分鐘…當時我就覺得你這家伙是個可造之材。