设计模式之单例模式

单例模式

一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建。

单例模式是指确保一个类在任何情况下都只有一个实例，并且提供一个访问该单例的全局访问点。

单例特点：

• 某个类只能有一个实例；（构造器私有）
• 它必须自行创建这个实例；（自己编写实例化逻辑）
• 它必须自行向整个系统提供这个实例；（对外提供实例化 方法）

分类

饿汉式单例

优点：在类加载的时候，instance 静态实例就已经创建并初始化好了，所以，instance实例的创建过程是线程安全的，执行效率高，性能好，没有锁。

缺点：因为不支持延迟加载，如果实例占用的资源多（比如占用内存多）或初始化耗时长（比如需要加载各种配置文件），提前初始化实例是一种浪费资源的行为。

java 代码：

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return instance;
    }
}

懒汉式单例（DCL）

优点：支持延迟加载，节省内存，线程安全。

缺点：代码可读性差，可通过反射破坏单例模式。

public class Person {
    private String name;
    private String age;

    private volatile static Person instance;

    // 构造器私有化，外部不能实例化
    private Person() {
    }

    // 提供给外部的方法
    public static Person getInstance() {
        if (instance == null) {
            synchronized (Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
        return instance;
    }
}

静态内部类（单例）

优点：使用时才会加载，而且静态内部变量只加载一次所以线程安全，性能高，避免内存浪费。

缺点：代码不够优雅。

public class StaticInnerClassLazySingleton {
    // 防止反射破坏
    private StaticInnerClassLazySingleton() {
        if (Objects.nonNull(StaticInnerSingleton.INSTANCE)) {
            throw new RuntimeException("禁止非法访问");
        }
    }

    private static class StaticInnerSingleton{
        public static final StaticInnerClassLazySingleton INSTANCE = new StaticInnerClassLazySingleton();
    }

    public static StaticInnerClassLazySingleton getInstance() {
        return StaticInnerSingleton.INSTANCE;
    }
}

原理：是利用了 Java 静态内部类的特性，即外部类加载时不会加载内部类，只有在使用到内部类时才会加载。因此，在第一次调用获取实例的方法时，才会加载静态内部类，并创建并初始化一个静态的实例对象，然后返回这个实例。

枚举类（单例）

优点：线程安全，不用担心反射破坏单例模式，性能高，没有任何锁。

缺点：枚举类占用内存多

public enum EnumSingleton {
    Enum_Singleton;
    private Object singletonTonData;

    public Object getSingletonTonData() {
        return singletonTonData;
    }
    public void setSingletonTonData(Object singletonTonData) {
        this.singletonTonData = singletonTonData;
    }
}

原理：是利用了Java枚举类型本身的特性，即枚举类型在加载时就会创建所有的枚举常量，并且保证了线程安全性和唯一性。

ThreadLocal（单例）

优点：通过线程隔离实现线程安全，性能高。

缺点：同个线程下的单例，以空间换时间。

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalSingleton = new ThreadLocal<ThreadLocalSingleton>() {
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };

    private ThreadLocalSingleton() {
    }

    public static ThreadLocalSingleton getInstance() {
        return threadLocalSingleton.get();
    }
}

什么场景用到？

• 多线程中的线程池
• 数据库的连接池
• 系统环境信息
• 上下文（ServletContext）

面试问题

• 系统环境信息（System.getProperties()）？
• Spring中怎么保持组件单例的
• ServletContext是什么？是单例嘛？怎么保证？
• ApplicationContext是什么？是单例嘛？怎么保证？
• 数据库连接池一般怎么创建出来的，怎么保证单实例？