單例模式（Singleton Pattern）是 Java 中最簡單的設(shè)計(jì)模式之一。是一種創(chuàng)建型設(shè)計(jì)模式。他的定義為：保證一個(gè)類僅有一個(gè)實(shí)例，并提供一個(gè)訪問它的全局訪問點(diǎn)。

單例模式一般體現(xiàn)在類聲明中，單例的類負(fù)責(zé)創(chuàng)建自己的對(duì)象，同時(shí)確保只有單個(gè)對(duì)象被創(chuàng)建。這個(gè)類提供了一種訪問其唯一的對(duì)象的方式，可以直接訪問，不需要實(shí)例化該類的對(duì)象。

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

以下，是一次面試現(xiàn)場(chǎng)的還原，之所以會(huì)聊到這個(gè)話題，是因?yàn)槊嬖嚬賳柫宋液芏嚓P(guān)于單例模式的問題，我回答的還可以，之后面試官隨口問了一句"單例絕對(duì)安全嗎？"，緊接著發(fā)生了如下對(duì)話：

Q：單例模式絕對(duì)安全嗎？ 

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

Q：哦？怎么說？ 

A：單例模式其實(shí)是對(duì)外隱藏了構(gòu)造函數(shù)，保證用戶無法主動(dòng)創(chuàng)建對(duì)象。但是實(shí)際上我們是有辦法可以破壞他的。

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

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

反射破壞單例

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

import java.io.Serializable;  
/**  
 * 使用雙重校驗(yàn)鎖方式實(shí)現(xiàn)單例  
 */  
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;  
    }  
} 

這個(gè)單例模式提供了一個(gè)private類型的構(gòu)造函數(shù)，正常情況下，我們無法直接調(diào)用對(duì)象的私有方法。但是反射技術(shù)給我們提供了一個(gè)后門。

如下代碼，我們通過反射的方式獲取到Singleton的構(gòu)造函數(shù)，設(shè)置其訪問權(quán)限，然后通過該方法創(chuàng)建一個(gè)新的對(duì)象： 

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

輸出結(jié)果為： 

singleton : com.dev.interview.Singleton@55d56113  
singletonByReflect : com.dev.interview.Singleton@148080bb  
singleton == singletonByReflect : false 

如上，通過發(fā)射的方式即可獲取到一個(gè)新的單例對(duì)象，這就破壞了單例。

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

A：其實(shí)是可以的，只要我們?cè)跇?gòu)造函數(shù)中加一些判斷就行了。

如下方式，我們?cè)赟ingleton的構(gòu)造函數(shù)中增加如下代碼： 

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

這樣，在通過反射調(diào)用構(gòu)造方法的時(shí)候，就會(huì)拋出異常： 

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

序列化破壞單例

Q：嗯嗯，挺不錯(cuò)的，那我們換個(gè)問題吧。

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

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

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

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

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();  
            //判斷是否是同一個(gè)對(duì)象 
            System.out.println("singleton : " + singleton);  
            System.out.println("singletonBySerialize : " + singletonBySerialize);  
            System.out.println("singleton == singletonBySerialize : " + (singleton == singletonBySerialize));  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
} 

輸出結(jié)果如下： 

singleton : com.dev.interview.Singleton@617faa95  
singletonBySerialize : com.dev.interview.Singleton@5d76b067  
singleton == singletonBySerialize : false 

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

因?yàn)樵趯?duì)象反序列化的過程中，序列化會(huì)通過反射調(diào)用無參數(shù)的構(gòu)造方法創(chuàng)建一個(gè)新的對(duì)象，所以，通過反序列化也能破壞單例。

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

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

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

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

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

A：因?yàn)榉葱蛄谢^程中，在反序列化執(zhí)行過程中會(huì)執(zhí)行到ObjectInputStream#readOrdinaryObject方法，這個(gè)方法會(huì)判斷對(duì)象是否包含readResolve方法，如果包含的話會(huì)直接調(diào)用這個(gè)方法獲得對(duì)象實(shí)例。

Q：那如果沒有readResolve方法的話，反序列化的時(shí)候會(huì)怎么創(chuàng)建對(duì)象呢？

A：當(dāng)然也是反射咯。

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

A：這個(gè)我還真試過，其實(shí)是不行的，反序列化使用的反射構(gòu)造器和我們代碼中使用反射的構(gòu)造器不是同一個(gè)，反序列化用到的構(gòu)造器并不會(huì)調(diào)用到我們對(duì)象中的構(gòu)造函數(shù)…balabala…（我也不知道面試官聽不聽得懂，感覺是沒聽懂…） 

Q：哦。OK吧，請(qǐng)問你什么時(shí)候可以來上班？

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