设计模式 ~ 单例模式

• 七种常见的单例模式

• 1、懒汉式

/**
 * 单例模式 ~ 懒汉式
 *
 * @author LTP  2021/11/9
 */
class Singleton_lazy {

    private static Singleton_lazy mInstance;

    private Singleton_lazy() {
    }

    public static Singleton_lazy getInstance() {
        if (mInstance == null) {
            mInstance = new Singleton_lazy();
        }
        return mInstance;
    }
}

• 特点：获取单例时判空即可，线程不安全

2、线程安全的懒汉式

/**
 * 单例模式 ~ 线程安全的懒汉式
 *
 * @author LTP  2021/11/9
 */
class Singleton_lazySync {

    private static Singleton_lazySync mInstance;

    private Singleton_lazySync() {
    }

    public static synchronized Singleton_lazySync getInstance() {
        if (mInstance == null) {
            mInstance = new Singleton_lazySync();
        }
        return mInstance;
    }
}

• 特点：在获取单例的方法上加synchronized关键字保证线程安全，但每次获取都加锁效率比较低

3、双重校验锁DCL（double check lock）

/**
 * 单例模式 ~ 双重校验锁DCL（Double check lock）
 * 是针对线程安全的懒汉式的优化版本
 *
 * @author LTP 2021/11/5
 */
public class Singleton_DCL {

    /**
     * volatile关键字（可见性、防止指令重排、不保证原子性）此处用到了防止指令重排的特性
     * 在一个线程分配了mInstance所指向的内存地址，但并未初始化时（发生指令重排），
     * 第二个线程在第一个判空的位置会判断mInstance不为空从而直接返回当前mInstance，但事实上mInstance并未初始化而造成错误
     * 具体参考：https://blog.csdn.net/llllllkkkkkooooo/article/details/115360630
     */
    private static volatile Singleton_DCL mInstance;

    private Singleton_DCL() {
    }

    public static Singleton_DCL getInstance() {
        // 第一个判空是减少synchronized加锁，提高效率
        if (mInstance == null) {
            // 执行位置1
            synchronized (Singleton_DCL.class) {
                // 第二次判空是防止有多个线程调用getInstance()时都执行在第一次判空之后并阻塞在synchronized之前（执行位置1）
                // 从而导致一个线程中初始化后下一个线程继续初始化，从而破坏单例
                if (mInstance == null) {
                    mInstance = new Singleton_DCL();
                }
            }
        }
        return mInstance;
    }
}

• 特点：线程安全的懒汉式的优化版本，减少加锁，提高代码效率
• volatile作用：参考：https://blog.csdn.net/llllllkkkkkooooo/article/details/115360630

4、饿汉式

/**
 * 单例模式 ~ 饿汉式
 *
 * @author LTP  2021/11/9
 */
class Singleton_hungry {

    private static final Singleton_hungry mInstance = new Singleton_hungry();

    private Singleton_hungry() {
        System.out.println("构造器");
    }

    public static Singleton_hungry getInstance() {
        return mInstance;
    }

    // 执行顺序：构造器-main
    public static void main(String[] args) {
        System.out.println("main");
        Singleton_hungry instance =Singleton_hungry.getInstance();
    }
}

• 特点：直接在类加载时初始化单例对象，保证唯一性

5、静态内部类

/**
 * 单例模式 ~ 静态内部类
 * 相比较饿汉式的好处是：第一次加载Singleton_staticInnerClass并不会初始化mInstance（调用构造器），
 * 只有在调用getInstance()时,才会加载SingletonHolder从而初始化mInstance,
 * 参考：https://blog.csdn.net/weixin_30530523/article/details/96640126
 *
 * @author LTP  2021/11/9
 */
class Singleton_staticInnerClass {

    private Singleton_staticInnerClass() {
        System.out.println("构造器");
    }

    public static Singleton_staticInnerClass getInstance() {
        return SingletonHolder.mInstance;
    }

    private static class SingletonHolder {
        public static final Singleton_staticInnerClass mInstance = new Singleton_staticInnerClass();
    }

    // 执行顺序：main-构造器
    public static void main(String[] args) {
        System.out.println("main");
        Singleton_staticInnerClass instance =Singleton_staticInnerClass.getInstance();
    }
}

• 特点：属于饿汉式的优化版本，不会在类加载时初始化，而是利用静态内部类在调用方法时才去初始化单例
• 对比饿汉式：参考：https://blog.csdn.net/weixin_30530523/article/details/96640126

6、枚举

/**
 * 枚举，一般不用枚举，可读性差，而且使用枚举会造成内存加大（每个枚举类都会申明成一个静态变量），Android不推荐
 *
 * @author LTP  2021/11/9
 */
class Singleton_enum {

    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.INSTANCE;
    }

    enum SingleTon {
        INSTANCE
    }
}

• 特点：简单，可读性差，而且Android不推荐使用枚举（加大内存占用）

7、容器类

package com.btpj.design_pattern.singleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 单例模式 ~ 容器
 * 多种单例类统一管理，在使用时根据key获取对象对应类型的对象。
 * 这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，
 * 降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度
 *
 * @author LTP 2021/11/5
 */
public class Singleton_map {

    /**
     * 使用Map容器类统一管理各单例实例
     */
    private static Map mObjMap = new ConcurrentHashMap<>();

    private Singleton_map() {
    }

    /**
     * 将实例保存至Map容器
     *
     * @param key      key
     * @param instance 实例
     */
    public static void addInstance(String key, Object instance) {
        if (!mObjMap.containsKey(key)) {
            mObjMap.put(key, instance);
        }
    }

    /**
     * 根据key获取单例类
     *
     * @param key key
     * @return 获取到的单例类
     */
    public static Object getInstance(String key) {
        return mObjMap.get(key);
    }
}

• 特点：可统一管理多种单例类，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度