单例模式 6种实现方法

懒汉式

当第一次调用的时候才会创建对象，合理占用资源。

/**
 * 懒汉式（线程安全）
 */public class Singleton01 {    private static Singleton01 singleton01;    // 私有构造方法
    private Singleton01() {
    }    // 同步获取单例对象，保证线程安全
    public static synchronized Singleton01 getInstance() {        // 单例对象为空的时候，创建单例对象
        if (singleton01 == null) {            return new Singleton01();
        }        return singleton01;
    }

}

饿汉式

类加载的时候就会初始化，他是线程安全的，但是类加载的时候就会初始化会预先消耗一部分资源。

/**
 * 饿汉式
 */public class SingleTon02 {

    private static SingleTon02 singleTon02 = new SingleTon02();    // 私有构造方法
    private SingleTon02() {
    }    public static SingleTon02 getInstance() {        return singleTon02;
    }
}

双检索式

该方式能保证需要的时候才初始化单例，还能保证线程安全，而且单例初始化的时候调用getInstance()不会进行同步锁。

/**
 * 双检索（DCL式）.
 */public class Singleton03 {    private volatile static Singleton03 singleton03;    // 私有构造方法
    private Singleton03() {
    }    // 同步该方法获取单例对象
    public static Singleton03 getInstance() {        // 但对象为空时同步这个方法
        if (singleton03 == null) {            synchronized (Singleton03.class) {                // 再判断是否为空
                if (singleton03 == null) {                    // 为空的话就创建对象
                    singleton03 = new Singleton03();
                }
            }
        }        return singleton03;
    }
}

静态内部类

内部类只有在getInstance()方法第一次调用的时候才会被加载（实现了延迟加载效果），而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候只实例化了一次instance

/**
 * 静态内部类，推荐该该方式实现单例模式.
 */public class Singleton04 {
    // 私有化构造方法
    private Singleton04() {
    }    /**
     * 静态内部类.
     * 内部类只有在getInstance()方法第一次调用的时候才会被加载（实现了延迟加载效果），
     * 而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候只实例化了一次instance
     */
    private static class Singleton05inner {
        public static final Singleton04 INSTANCE = new Singleton04();
    }    public static Singleton04 getInstance() {        return Singleton05inner.INSTANCE;
    }
}

枚举

枚举是线程安全的，而且任何情况下都是一个实例，枚举不能实例化，不能被反射。

/**
 * 枚举.
 */public enum Singleton05 {
    INSTACNE;    public static Singleton05 getInstacne() {        return INSTACNE;
    }
}

容器实现单例

容器实现单例，它的好处是可以统一管理单例。

/**
 * 容器实现单例.
 * 它的好处是可以统一的管理单例，安卓中getSystemService(String name)就是用这种方式实现的.
 */public class Singleton06 {

    private static Map<String, Object> singletonManagerMap = new HashMap<>();    // 私有构造方法
    private Singleton06() {
    }    // 注入程序中的单例
    public static void registerSingleton(String key, Object instance) {        if (!singletonManagerMap.containsKey(key)) {
            singletonManagerMap.put(key, instance);
        }
    }    // 获取key值对应的单例对象
    public static Object getInstance(String key) {        return singletonManagerMap.get(key);
    }
}

作者：lconcise
链接：https://www.jianshu.com/p/5e54539cfd2e