六种单列模式

确保某一个类只有一个实例.

(1)饿汉式单列:

public class SingleOne {
    //成员位置开始创建  静态+final 确保实例单一
    private static final SingleOne ourInstance = new SingleOne();

    //对外获取
    public static SingleOne getInstance() {
        return ourInstance;
    }

    //构造方法私有 禁止创建
    private SingleOne() {
    }
}

(2)懒汉式单列

public class SingleTwo {

    private static SingleTwo singleTwo;

    private SingleTwo() {

    }

    //同步方法  每次调用都同步 消耗资源
    public static synchronized SingleTwo getInstance() {
        //使用时创建
        if (singleTwo == null) {
            singleTwo = new SingleTwo();
        }
        return singleTwo;
    }


}

(3)DCL(Double Check Lock) 单列  会失效

public class SingleThree {

    private static SingleThree singleThree;

    private SingleThree() {
    }

    public static SingleThree getInstance() {

        if (singleThree == null) {//不要每次同步
            synchronized (SingleThree.class) {//线程安全
                if (singleThree == null) {
                    singleThree = new SingleThree();
                }
            }
        }
        return singleThree;
    }
}

(4)静态内部类单列

public class SingleFour {

    private SingleFour() {

    }

    //第一次调用 SINGLE_FOUR 才会实例化 线程安全 对象唯一 延迟加载 推荐使用
    public static SingleFour getInstance() {
        return SingleHolder.SINGLE_FOUR;
    }


    private static class SingleHolder {
        private static final SingleFour SINGLE_FOUR = new SingleFour();
    }

}

(5)枚举单列:

public enum SingleFive {

    //枚举创建是线程安全的 并且是一个单列
    INSTANCE;

    public String testString = "hello";

    public void test() {

    }

}

(6)容器单列

public class SingleSix {

    private static Map<String, Object> objectMap = new HashMap<>();

    private SingleSix() {
    }

    public static void registerService(String key, Object value) {
        if (!objectMap.containsKey(key)) {
            objectMap.put(key, value);
        }
    }

    public static Object getService(String key) {
        return objectMap.get(key);
    }

}