看如下案例：

/**
 * DCL
 */
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;
    }
}

写一个序列化的测试类：

public class SerializableDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // Write to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(Singleton.getSingleton());
        // Read from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        System.out.println(newInstance == Singleton.getSingleton());
    }
}
//false

通过对Singleton的序列化与反序列化得到的对象是一个新的对象，这就破坏了Singleton的单例性。

序列化破坏单例的过程
在反序列化的过程中

ObjectInputStream
对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的。为了节省篇幅，这里给出ObjectInputStream的readObject的调用栈：

重点代码，readOrdinaryObject方法的代码片段：

private Object readOrdinaryObject(boolean unshared)
           throws IOException
       {
           //此处省略部分代码
   
           Object obj;
           try {
               obj = desc.isInstantiable() ? desc.newInstance() : null;
           } catch (Exception ex) {
               throw (IOException) new InvalidClassException(
                   desc.forClass().getName(),
                   "unable to create instance").initCause(ex);
           }
   
           //此处省略部分代码
   
           if (obj != null &&
               handles.lookupException(passHandle) == null &&
               desc.hasReadResolveMethod())
           {
               Object rep = desc.invokeReadResolve(obj);
               if (unshared && rep.getClass().isArray()) {
                   rep = cloneArray(rep);
               }
               if (rep != obj) {
                   handles.setObject(passHandle, obj = rep);
               }
           }
   
           return obj;
       }

Object obj;
            try {
                obj = desc.isInstantiable() ? desc.newInstance() : null;
            } catch (Exception ex) {
                throw (IOException) new InvalidClassException(
                    desc.forClass().getName(),
                    "unable to create instance").initCause(ex);
            }

这里创建的这个obj对象，就是本方法要返回的对象，也可以暂时理解为是ObjectInputStream的readObject返回的对象。

isInstantiable：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。

desc.newInstance：该方法通过反射的方式调用无参构造方法新建一个对象。

这就解释了原因，为什么序列化会破坏单例?：序列化会通过反射调用无参数的构造方法创建一个新的对象。

防止序列化破坏单例模式
先给出解决方案，然后再具体分析原理：

扫描二维码关注公众号，回复： 11130741 查看本文章

只要在Singleton类中定义readResolve就可以解决该问题：

    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 Object readResolve() {
            return singleton;
        }
    }

还是运行以下测试类：

import java.io.*;
    /**
     */
    public class SerializableDemo1 {
        //为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
        //Exception直接抛出
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            //Write Obj to file
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
            oos.writeObject(Singleton.getSingleton());
            //Read Obj from file
            File file = new File("tempFile");
            ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
            Singleton newInstance = (Singleton) ois.readObject();
            //判断是否是同一个对象
            System.out.println(newInstance == Singleton.getSingleton());
        }
    }
    //true

本次输出结果为true。具体原理，我们回过头继续分析以下ObjectInputStream的readObject的调用代码:

  if (obj != null &&
                handles.lookupException(passHandle) == null &&
                desc.hasReadResolveMethod())
            {
                Object rep = desc.invokeReadResolve(obj);
                if (unshared && rep.getClass().isArray()) {
                    rep = cloneArray(rep);
                }
                if (rep != obj) {
                    handles.setObject(passHandle, obj = rep);
                }
            }

hasReadResolveMethod:如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true

invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。

所以，原理也就清楚了，主要在Singleton中定义readResolve方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。