单例设计模式

单例模式属于创建型模式，用于在系统运行过程中保证只有一个实例。
创建单例面临的问题有：反射破坏单例，多线程并发破坏、序列化破坏单例

1 饿汉式单例

/**
 * 懒汉式单例
 * 已解决反射破坏、序列化问题
 * 类加载时就创建了单例，不存在线程安全问题
 */
public class HungrySingleton {
    // 类加载时就初始化
    private static HungrySingleton hungrySingleton = new HungrySingleton();
    // 构造方法私有化
    private HungrySingleton(){
        // 防止反射破坏单例
        if (hungrySingleton != null) {
            throw new RuntimeException("非法访问");
        }
    }
    // 全局访问点
    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
    // 防止反序列化破环单例，ObjectInputStream桥接的方法。在反序列化时会调用readResolve方法返回单例
    public HungrySingleton readResolve() {
        return hungrySingleton;
    }
}

2 懒汉式单例

/**
 * 懒汉式单例
 * 双重检查解决并发问题
 * 可以被反射破坏、反序列化破坏
 */
public class LazySingleton {
    // 加volatile，防止指令重排序问题。保证线程间可见性
    private volatile static LazySingleton lazySingleton;
    // 构造方法私有化
    private LazySingleton(){}
    // 全局访问点
    private static LazySingleton getInstance() {
        if (lazySingleton == null) {
            synchronized (LazySingleton.class) {
                if (lazySingleton == null) {
                    lazySingleton = new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }
}

/**
 * 懒汉式单例，静态内部类加载的方式
 * 是线程安全的
 * 可以被反射破坏、反序列化破坏
 */
public class LazyInnerSingleton {
    // 构造方法私有化
    private LazyInnerSingleton(){}

    public static LazyInnerSingleton getInstance() {
        return LazyInner.LAZY_INNER_SINGLETON;
    }
    // 静态内部类在使用时再加载，未使用时不浪费内存
    private static class LazyInner {
        private static final LazyInnerSingleton LAZY_INNER_SINGLETON = new LazyInnerSingleton();
    }
}

3 容器式单例

枚举式单例、注册式单例、线程隔离的单例

3.1 枚举式单例

Jdk提供的Enum类型

/**
 * 枚举式单例
 * 容器式，但在类装载时就初始化占用内存。是线程安全的
 * 不可被反射破坏，JDK层禁止反射创建枚举类型对象。
 * 不可被反序列化破坏，JDK底层限制can't deserialize enum
 */
public enum EnumSingleton {
    INSTANCE;
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

3.2 注册式单例

spring的利用ioc容器存储单例的形式

/**
 * spring容器式单例
 * 在类getInstance使用时才装载到内存中。
 * 
 * 反射破坏，容器本身会被反射破坏，必要时采取保护措施
 * 反序列化破坏，容器本身会被反射序列化破坏，必要时采取保护措施
 * Map中只会保存一个类的实例，但不是绝对场景的线程安全。当第一次初始化时单例时两个线程同时进入就可能存在put被覆盖。必要时采取保护措施
 */
public class IocSingleton {
    // 初始化一个容器，用于装载各种类的单例
    private static Map<String, Object> ioc = new HashMap<>();
    // 构造方法私有化
    private IocSingleton(){}
    // 根据需要的对象类型，获取对应的实例
    public static Object getInstance(Class clazz) {
        String name = clazz.getName();
        if (!ioc.containsKey(name)) {
            Constructor constructor = clazz.getConstructor(null);
            constructor.setAccessible(true);
            Object o = constructor.newInstance();
            ioc.put(name, o);
        }
        return ioc.get(name);
    }
}

3.3 线程隔离式单例

利用ThreadLocal类为每个线程提供线程间相互隔离的单例

/**
 * 线程隔离的单例。
 * 容器式单例，一个线程创建一个单例
 * 该场景内是线程安全的。
 * 反射破坏，容器本身会被反射破坏，必要时采取保护措施
 * 反序列化破坏，容器本身会被反射序列化破坏，必要时采取保护措施
 */
public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocal
            = new ThreadLocal<ThreadLocalSingleton>(){
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };
    private ThreadLocalSingleton(){}

    public static ThreadLocalSingleton getInstance() {
        return threadLocal.get();
    }
}