简洁全面的单例模式整理

单例实现

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

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