单例模式之Java版本以及5种写法

/**
 * 一、单例是什么？
 *     确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。即：让整个生命周期内只有一个实例。
 * 二、为什么使用单例？——内存、资源
 *     1、一个类专门提供一些公共功能供别人调用，而本身并不会处理业务逻辑，那么创建多个实例，会消耗内存，造成不必要的开销，此时需要单例。
 *     2、如果创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就要考虑使用单例模式。                 
 *     3、总的来说，如果该类 需要消耗较多资源 或者 没有多个实例，考虑使用单例。
 * 三、单例实现方式？
 *     常见单例模式有如下五种写法：懒汉式，双重校验锁，静态内部类，饿汉式和枚举；以及一种不常见写法：使用容器实现单例。
 *     懒汉式：非线程安全
 *     双重校验锁：线程安全
 *     静态内部类：线程安全
 *     饿汉式：线程安全
 *     枚举：线程安全
 *     容器实现：非线程安全
 * 四、单例优缺点？
 *     优点：1、减少内存开销；2、减少系统性能开销；3、避免对资源的重复占用；4、优化和共享资源访问。
 *     缺点：1、不容易扩展，基本只能通过修改代码去扩展；2、如果持有了context就容易引发内存泄漏，建议使用ApplicationContext。
 */


// 五、代码实现
///**
// * 懒汉式1：原始版，会有多线程并发问题。——不建议使用
// * 由于instance是静态的，因此能够保证程序运行过程中只存在一个实例。
// * 但是针对多线程情况，就可能有问题。当有多个线程同时执行到line行时，会各自new一个对象出来。存在多个实例，违背了单例模式的概念。
// */
//public class Singleton{
//    private static Singleton instance;
//    private Singleton() {}
//    public static Singleton getInstance() {
//        if (instance == null) {
//            instance = new Singleton(); // line
//        }
//        return instance;
//    }
//}

///**
// * 懒汉式2：改进懒汉式1，多线程高并发时效率低。——不建议使用
// */
//public class Singleton{
//    private static Singleton instance;
//    private Singleton() {}
//
//    // 对方法加锁
//    public static synchronized Singleton getInstance() {
//        if (instance == null) {
//            instance = new Singleton();
//        }
//        return instance;
//    }
//
////    // 对对象加锁，和对方法加锁一个效果，是走向懒汉式3的一个中间过程
////    public static Singleton getInstance() {
////        synchronized (Singleton.class) {
////            if (instance == null) {
////                instance = new Singleton();
////            }
////            return instance;
////        }
////    }
//}

/**
 * 懒汉式3：改进懒汉式2，Double-Checked Locking(DCL)双重校验锁方式。——一般情况下可使用
 *     1、并不是每次进入getInstance方法都要获得锁。对instance访问分为两类：读和写。仅当instance为null的时候才会写，此时获得锁；其他情况就只是读操作，此时不需要获得锁了。
 *
 *     2、DCL的优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。
 *
 *     3、DCL的缺点：第一次加载时反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。
 *
 *     4、小插曲之JDK1.5之前DCL的小缺点：
 * JDK1.5之前的Java中无法安全使用DCL来实现单例模式，尽管得到了Singleton的正确引用，但是却有可能访问到其成员变量的不正确值。我们知道instance = new Singleton();语句，实际上它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，大致包括以下3件事情：
 * （1）给Singleton的实例分配内存；（2）调用Singleton()的构造函数，初始化成员字段；（3）将instance对象指向分配的内存空间（此时instance就不是null了）。
 * 但由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（Java Memory Model，即Java内存模型）中Cache、寄存器到主内存回写顺序的规定，上面的第2和第3的顺序是无法保证的。
 * volatile屏蔽指令重排序的语义在JDK1.5中才被完全修复，可参见java的“happen-before”八大原则规则的第三条，volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作。
 *
 * ⚠️注意：DCL在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但它还是在某些情况下出现失效的问题，虽然发生概率很小。
 */
public class Singleton{
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

///**
// * 静态内部类单例模式——推荐使用
// * 可以同时保证线程安全、延迟加载，以及单例对象的唯一性。
// * 1、它与饿汉式一样，也是利用了类加载机制来保证只创建一个instance实例，因此不存在多线程并发的问题。
// * 2、当第一次加载Singleton类时并不会初始化instance，只有在第一次调用getInstance方法时才会导致instance被初始化，因此做到了延迟加载。
// */
//public class Singleton {
//    private static class SingletonHolder {
//        private static final Singleton instance = new Singleton();
//    }
//    private Singleton() {}
//    public static Singleton getInstance() {
//        return SingletonHolder.instance;
//    }
//}

///**
// * 饿汉式
// */
//public class Singleton {
//    private static final Singleton instance = new Singleton();
//    private Singleton() {}
//    public static Singleton getInstance() {
//        return instance;
//    }
//}

///**
// * 枚举
// * 访问方式：SingletonEnum.instance.method();
// * 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
// */
//public enum SingletonEnum {
//    instance;
//    private SingletonEnum() {}
//    public void method(){
//    }
//}

///**
// * 使用容器实现单例模式
// *《在Android源码设计模式解析与实战》一书中还提到了使用容器实现单例模式的方式，便于管理，以及可以隐藏具体实现和降低耦合度等，但不是线程安全的，由于不是常见实现方式，就不再在此赘述。
// */


// 六、总结
// 不管以哪种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象的问题。
// 总的来说，选取哪种方式实现单例模式取决于项目本身，比如：是否是复杂的并发环境、JDK版本是否过低、单例对象的资源消耗等