Java实现线程安全单例模式的五种方式的示例代码

// 问题1：为什么加 final
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例
public final class Singleton_hungry implements Serializable {

    // 问题3：为什么设置为私有? 是否能防止反射创建新的实例?
    private Singleton_hungry(){}

    // 问题4：这样初始化是否能保证单例对象创建时的线程安全?
    private static Singleton_hungry INSTANCE = new Singleton_hungry();

    // 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由
    public static Singleton_hungry getInstance() {
        return INSTANCE;
    }
    public Object readResolve(){  // 防止反射创建新的实例?
        return INSTANCE;
    }
}

enum Singleton { 
   INSTANCE; 
}

public final class Singleton_lazy {
    private Singleton_lazy(){}
    private static Singleton_lazy INSTANCE = null;
    // 缺点
    public static synchronized Singleton_lazy getInstance() {
        if(INSTANCE != null) {
            return INSTANCE;
        }
        INSTANCE = new Singleton_lazy();
        return INSTANCE;
    }
}

public final class Singleton_DCL {

    private Singleton_DCL() {}

    // 问题1：解释为什么要加 volatile ?
    private static volatile Singleton_DCL INSTANCE= null;

    // 问题2：对比实现3, 说出这样做的意义
    public static Singleton_DCL getInstance() {
        if(INSTANCE != null) {
            return INSTANCE;
        }
        synchronized (Singleton_DCL.class) {
          
            // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
            if(INSTANCE != null) {
                return INSTANCE;
            }
            INSTANCE = new Singleton_DCL();
            return INSTANCE;
        }
    }
}

public final class Singleton_LazyHolder {
    private Singleton_LazyHolder(){}

    // 问题1：属于懒汉式还是饿汉式
    private static class LazyHolder{
        static final Singleton_LazyHolder INSTANCE = new Singleton_LazyHolder();
    }

    // 问题2：在创建时是否有并发问题
    public static Singleton_LazyHolder getInstance() {
        return LazyHolder.INSTANCE;
    }
}