定义

单例模式 ：一个类只允许创建一个对象或实例。

使用场景

1.处理资源访问冲突，多线程同时访问
2.表示全局唯一类，从业务上来讲，如果有些数据在系统中只保存一份，适合设计成单例类。

实现单例关注点

• 构造函数访问权限为private,避免外部通过new创建实例
• 考虑对象创建时的线程安全问题
• 考虑是否支持延迟加载
• 考虑getInstance()性能是否高（是否加锁）

五种单例

/**
 * 懒汉式：支持延迟加载
 * getInstance()函数加锁操作，导致函数并发度很低，并发度为1，相当于串行操作。如果函数被频繁用到的话，
 * 频繁的加锁、释放锁及并发度低等问题，会导致性能瓶颈。
 */
public class Singleton1 {
    private static Singleton1 instance;
    private Singleton1(){}
    public static synchronized Singleton1 getInstance(){
        if (instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

/**
 * 饿汉式：会一直占用着资源
 * 说法1:如果实例占用资源多或者初始化耗时长，提前初始化实例是一种浪费资源的行为，应该在用到时再去初始化。
 *
 * 说法2：1.如果初始化耗时长，在用到时再去初始化的话，会影响到系统性能。比如在请求接口时，做初始化操作，会导致请求的响应时间
 * 变长。耗时的初始化操作提前到启动时完成，能避免程序运行时导致的性能问题。
 * 2.如果实例占用资源多。我们在程序启动时就能触发报错，我们可以立即修复，能避免程序运行一段时间后，突然初始化实例占用资源多，
 * 导致系统崩溃，影响系统性能。
 *
 * 如果耗时短，占用资源少的话，在什么时候都可以。
 */
public class Singleton2 {
    private static final Singleton2 instance = new Singleton2();
    private Singleton2(){}
    public static Singleton2 getInstance(){
        return instance;
    }
}

/**
 * 双重检测:既支持延迟加载，也支持高并发。
 *
 *  在instance创建之后，调用getInstance()函数，不会进入加锁逻辑，解决了懒汉式并发度低的问题。
 *  如果不用volatile修饰的话，因为指令重排序，可能会导致对象被new出来复制给instance之后，还没来得及执行构造函数
 *  中的代码逻辑，就被另一个线程使用了。
 *  volatile关键字可以禁止指令重排序。在低版本java中才会出现指令重排序，高版本的java已经在JDK中解决了这个问题，只要把
 *  对象new操作和初始化操作设计成原子操作，就能禁止指令重排序
 */
public class Singleton3 {
    private volatile static Singleton3 instance;//volatile关键词确保：在instance变量被初始化Singleton实例时，多个线程正确的处理instance变量
    private Singleton3(){}
    public static Singleton3 getInstance(){
        if (instance == null){
            synchronized (Singleton3.class){
                if (instance == null) instance = new Singleton3();
            }
        }
        return instance;
    }
}

/**
 * 静态内部类
 * SingletonHolder是一个静态内部类，当外部类Singleton4被加载的时候，并不会
 * 创建SingletonHolder实例对象，只有当调用getInstance()函数时，SingletoneHolder菜
 * 会被加载，此时才会创建instance.instance的唯一性、创建过程的线程安全性，都由JVM来
 * 保证。这种实现方式既保证线程安全，又能做到延迟加载。
 */
public class Singleton4 {

    private Singleton4(){}

    private static class SingletonHolder{
        private static final Singleton4 instance = new Singleton4();
    }

    public static Singleton4 getInstance(){
        return SingletonHolder.instance;
    }
}

/**
 * 枚举
 * 通过java枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。
 */
public enum Singleton5 {
    INSTANCE;

}

单例模式存在的问题：

1.单例对面向对象的支持不友好。
(1)违背了基于接口而非实现的设计原则，违背了广义上理解的面向对象的特性。如果未来某一天，需要更换业务算法，就会修改
所有用到单例类的地方，代码改动比较大。理论上讲，单例类也可以被继承，可以实现多态，但是会导致代码可读性变差。
2.单例会隐藏类之间的依赖关系
我们通过构造函数、参数传递等来了解到依赖关系，单例不需要显示创建、不需要依赖参数传递，只有阅读代码实现才可以知道依赖关系。
3.单例对代码的扩展性不友好
单例类只能有一个对象实例，如果我们需要在代码中创建两个或者多个实例，这种情况下不适合设计成单例模式。
4.单例不支持有参数的构造函数
实现有参数的需求有三种方式，第一种.调用init()函数，传递参数，再通过getInstance()来创建需要参数的实例，
第二种是将参数直接放到getInstance()中，第三种是使用一个Config类来存储参数变量，通过静态常量来定义，单例初始化时，
从Config中去取变量