Java | 设计模式-单例模式

单例模式：

确保某一个类只有一个实例，通过将类的实例化方法私有化来防止程序通过其他方式创建该类的实例，然后通过提供一个全局唯一获取该类实例的方法来获取类的实例。

若一个全局类的对象在多个地方被使用并且对象的状态时全局变化的场景下，可以考虑使用单例模式。

单例模式常见的写法有以下几种：

/**
 * 懒汉模式(线程安全)
 * 1、构造方法私有化
 * 2、定义一个私有静态对线instance(静态属性或方法属于类)
 * 3、定义加锁的静态方法获取该对线(加锁且先检查再执行)
 * */
class LazySingleton{
    private static LazySingleton instance;
    private LazySingleton(){}

    public static synchronized LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

/***
 *饿汉模式(CLass Loader完成后该类的实例便存在于JVM中)
 * 1、构造方法私有化
 * 2、在类中直接定义全局的静态对象的实例并初始化
 * 3、提供静态方法获取该实例对象
 */
class HungrySingleton{
    private static HungrySingleton instance = new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return instance;
    }
}

/**
 * 静态内部类(类的静态内部类在JVM中是唯一)
 * 1、构造方法私有化
 * 2、在类中定义一个静态内部类，并在内部类中完成对象实例的定义和初始化
 * 3、定义获取对象方法，并通过静态内部类调用其单例对象
 */
class OuterSingleton{
    private static class InnerSingleton{
        private static final OuterSingleton INSTANCE = new OuterSingleton();
    }
    private OuterSingleton(){}
    public static final OuterSingleton getInstance(){
        return InnerSingleton.INSTANCE;
    }
}

/**
 * 双重校验锁(在饿汉模式基础上进一步优化)
 * 1、构造方法私有化
 * 2、在定义静态对象时加volatile锁来确保初始化时对象的唯一性
 * 3、定义获取对象实例方法，并在方法体中通过synchronized(Object)给单例类加锁来保障操作的唯一性
 * */
class DoubleCheckedLockingSingleton{
    private volatile static DoubleCheckedLockingSingleton instance;
    private DoubleCheckedLockingSingleton(){}
    public static DoubleCheckedLockingSingleton getInstance(){
        if(instance == null){
            synchronized (DoubleCheckedLockingSingleton.class){
                if(instance == null)
                    instance = new DoubleCheckedLockingSingleton();
            }
        }
        return instance;
    }
}