设计模式之单例模式

定义

单例模式是指在任何情况下一个类只有一个实例，并提供一个全局访问点

饿汉式单例

在单例类首次加载的时候就创建实例

public class SingletonTest {

    private static final SingletonTest singleton = new SingletonTest();

    private SingletonTest() {
    }

    public static SingletonTest getInstance() {
        return singleton;
    }
}

懒汉式单例

被外部类调用时才创建

public class SingletonTest {

    private volatile static SingletonTest singleton;

    private SingletonTest() {
    }

    /**
     * 线程不安全
     * @return
     */
    public static SingletonTest getInstance() {
        if(null == singleton) {
            singleton = new SingletonTest();
        }
        return singleton;
    }

    /**
     * 双重检查
     * @return
     */
    public static SingletonTest getInstance2() {
        if(null == singleton) {
            synchronized (SingletonTest.class) {
                if(null == singleton) {
                    singleton = new SingletonTest();
                }
            }
        }
        return singleton;
    }
}

静态内部内写法，静态内部类在用的时候才会分配内存

public class SingletonTest {

    private SingletonTest() {}

    public static SingletonTest getInstance() {
        return LazySingleton.INSTANCE;
    }

    private static class LazySingleton {
        private static final SingletonTest INSTANCE = new SingletonTest();
    }
}

枚举式单例

自动支持序列化机制，绝对防止多次实例化

public enum SingletonTest {

    INSTANCE;

    private LazySingleton lazySingleton;

    public LazySingleton getInstance() {
        return INSTANCE.lazySingleton;
    }

    private SingletonTest() {
        lazySingleton = new LazySingleton();
    }

    private static class LazySingleton {

    }
}

容器式单例

将每一个实例都缓存到统一的容器中，使用唯一标识获取实例，容器式单例适用于创建实例非常多的情况

public class SingletonTest {

    private static final Map<String, Class> ioc = new ConcurrentHashMap<>();

    public static Class getBean(String className) throws ClassNotFoundException {
        if(!ioc.containsKey(className)) {
            ioc.put(className, Class.forName(className));
        }
        return ioc.get(className);
    }
}