单例

一、相关概念

单例：是java23中常见的设计模式之一，属于创建型模式，保证一个类只有一个实例，并对外提供调用对象该实例的方法。

意图：保证一个类在应用全局只有一个对象，减少对象的品频繁创建。

何时使用：控制实例数量，减少对象的创建，优化系统资源。

关键代码：1、构造函数私有；2、单例使用静态引用。

二、实现方式

从实例初始化的时机可以分为饿汉式、懒汉式。

饿汉式：资源加载时实例就被初始化，一般是在借用类加载机制，在类加载的初始化单例对象，可以避免多线程同步问题，但是容易产生系统垃圾。

懒汉式：第一次需要单例对象时调用单例的实现方法，可以避免内存浪费。

从线程安全性角度来说，可以分为单线程、多线程安全。

还有业内通用的DCL模式，即双检锁/双重校验锁（DCL，即 double-checked locking）。

1、懒汉式，线程不安全

该方法只适用于单线程，若是在多线程情况下，多线程走到instance==null，可能生成多个实例。

 static class Singleton1 {
        
        private static Singleton1 instance;
        private Singleton1(){}
        public static Singleton1 getInstance(){
            if(instance==null){
                instance=new Singleton1();
            }
            return instance;
        }

        public static void main(String[] args) {
            Singleton1 instance1 = getInstance();
            Singleton1 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        }
    }

2、懒汉式，线程安全

该方法可用于多线程，懒汉式加载，第一次调用时初始化对象，节省内存，使用synchronized保证对象唯一，但是加锁印象到效率

 static class Singleton2 {
        private static Singleton2 instance;
        private Singleton2(){};
        public static synchronized Singleton2 getInstance(){
            if (instance==null){
                instance=new Singleton2();
            }
            return instance;
        }
        public static void main(String[] args) {
            Singleton2 instance1 = getInstance();
            Singleton2 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        }
    }

3、饿汉式

该方法用静态方法修饰并初始化变量，利用类加载机制保证对象的唯一性。但是属于饿汉式，不是懒加载，浪费内存，好处是容易理解。

   static class Singleton3 {
        private static Singleton3 instance=new Singleton3();
        private Singleton3(){}
        private static Singleton3 getInstance(){
            return instance;
        }
        public static void main(String[] args) {
            Singleton3 instance1 = getInstance();
            Singleton3 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        }
    }

4、双检锁/双重校验锁（DCL，即 double-checked locking）

业界广泛，面试常问的单例模式。

好处：1、第一次校验可以减少加锁的次数，提高使用效率，在多线程下保证高性能；

2、懒汉式加载，只有在第一次调用时初始化对象，节省内存；

3、使用volatile，利用其禁止指令重排的特性，在初始化instance对象时可以保证强唯一性。

static class Singleton4 {
        private volatile static Singleton4 instance;
        private Singleton4(){}
        public static Singleton4 getInstance(){
            if (instance==null){
                synchronized (Singleton4.class){
                    if (instance==null){
                        instance=new Singleton4();
                    }
                }
            }
            return instance;
        }
        public static void main(String[] args) {
            Singleton4 instance1 = getInstance();
            Singleton4 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        }
    }

5、登记式/静态内部类

特征和好处：1、首先使用静态方法保证对象的唯一性；

2、内部类的使用又保证在第一次调用时初始化对象，节省内存；

static class Singleton5 {
        private static class Singleton5Holder{
            private static final Singleton5 SINGLETON_5=new Singleton5();
        }
        public static Singleton5 getInstance(){
            return Singleton5Holder.SINGLETON_5;
        }
        public static void main(String[] args) {
            Singleton5 instance1 = getInstance();
            Singleton5 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        } 
    }

6、枚举

枚举是jdk1.5之后推出，该单例实现方式在业内使用的并不频繁，但是该方法可以避免反序列化重新创建对象，可以保证绝对唯一性。

    enum  Singleton6 {
        INSTANCE;
        public static Singleton6 getInstance(){
            return INSTANCE;
        }
        public static void main(String[] args) {
            Singleton6 instance1 = getInstance();
            Singleton6 instance2 = getInstance();
            log.info("实例对象是否相等： "+instance1.equals(instance2));
        }
    }

总结：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

单例的几种实现方式