序列化破坏单例模式

一个单例对象创建好后，有时候需要将对象序列化然后写入磁盘，下次使用时再从磁盘中读取对象并进行反序列化，将其转化为内存对象。反序列化后的对象会重新分配内存，即重新创建，如果序列化的对象目标为单例对象，就违背了单例模式的初衷，相当于破坏了单例。

序列化就是把内存中的状态通过转换成字节码的形式。从而转换一个I/O流，写入其他地方（可以是磁盘，网络I/O）.内存中的状态会永久保存下来。

反序列化就是讲已经持久化的字节码对象转换成/O流，通过I/O流的读取，，进而讲读取的内容转换成java对象，在转换过程中会重新创建对象new .
例如：

public class GuPaoSingleton implements Serializable {

    private static final GuPaoSingleton GU_PAO_SINGLETON = new GuPaoSingleton();

    private GuPaoSingleton() {}

    public static GuPaoSingleton getInstance() {
        return GU_PAO_SINGLETON;
    }
}

编写测试代码：

public static void main(String[] args) {

        SerializableSingleton s1 = null;
        SerializableSingleton s2 = SerializableSingleton.getInstance();

        FileOutputStream fos = null;
        try {

            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SerializableSingleton) ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

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

运行结果如下图所示：
从运行结果可以看出，反序列化的对象和手动创建的对象是不一样的。实例化了两次，违背了单例模式的设计初衷。那么，我们如何保证在序列化的情况下也能够实现单例模式呢？其实，我们只要加上readResolve()方法即可，来看优化后的代码：运行结果如下所示：
有兴趣的同学可以去了解下JDK的源码实现。
ObjectInputStream类的readObject()方法。

缺点：虽然增加了readResolve()方法返回实例解决了单例模式破坏的问题，但是实际上实例化了两次，只不过新创建的对象没有返回而已，如果创建对象的动作发生频率加快，就意味着内存分配也会随之增大。