设计模式五种不同的单例模式懒汉式饿汉式枚举单例容器化单例(Spring单例源码分析) 线程单例

news2024/11/27 6:20:03

单例模式

第一种饿汉式

优点：执行效率高，性能高，没有任何的锁

缺点：某些情况下，可能会造成内存浪费

/**
 * @author LionLi
 */
public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton(){}

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

测试用例与结果

/**
 * @author LionLi
 */
public class Test {
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(5);
        PrintStream out = System.out;
        executor.execute(() -> out.println(HungrySingleton.getInstance()));
        executor.execute(() -> out.println(HungrySingleton.getInstance()));
        executor.execute(() -> out.println(HungrySingleton.getInstance()));
        executor.execute(() -> out.println(HungrySingleton.getInstance()));
        executor.execute(() -> out.println(HungrySingleton.getInstance()));
        executor.shutdown();
    }
}

多次运行符合要求不会出现问题

第二种懒汉式

优点：节省了内存,线程安全
缺点：性能低

测试用例以下通用

/**
 * @author LionLi
 */
public class Test {
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(5);
        PrintStream out = System.out;
        executor.execute(() -> out.println(LazySingletion.getInstance()));
        executor.execute(() -> out.println(LazySingletion.getInstance()));
        executor.execute(() -> out.println(LazySingletion.getInstance()));
        executor.execute(() -> out.println(LazySingletion.getInstance()));
        executor.execute(() -> out.println(LazySingletion.getInstance()));
        executor.shutdown();
    }
}

第一版本

/**
 * @author LionLi
 */
public class LazySingletion {
    private static LazySingletion instance;
    private LazySingletion(){}

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

测试失败无法保证单例

第二版本增加 synchronized 锁

/**
 * @author LionLi
 */
public class LazySingletion {
    private static LazySingletion instance;
    private LazySingletion(){}

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

测试成功可以保证单例但性能较低所有的线程全都被阻塞到方法外部排队处理

第三版本细化锁只锁创建方法提高性能

优点: 性能高了，线程安全了

缺点：可读性难度加大，不够优雅

此方法在各大开源框架源码内最为常见又名双重校验单例

/**
 * @author LionLi
 */
public class LazySingleton {
    /**
     * volatile 保证原子性具体用法百度
     */
    private volatile static LazySingleton instance;
    private LazySingleton(){}

    public static LazySingleton getInstance(){
        // 检查实例是否已经初始化 如果已经初始化直接返回 避免进入锁提高性能
        if (instance == null) {
            synchronized (LazySingleton.class) {
                // 重新检查是否已经被其他线程初始化
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

测试成功可以保证单例性能还高可以避免不必要的加锁

第三种枚举单例

在这种实现方式中，既可以避免多线程同步问题，还可以防止通过反射和反序列化来重新创建新的对象。

Java虚拟机会保证枚举对象的唯一性，因此每一个枚举类型和定义的枚举变量在JVM中都是唯一的。

/**
 * @author LionLi
 */
public enum EnumSingleton {
    INSTANCE;
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
}

测试代码与结果

/**
 * @author LionLi
 */
public class Test {
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(5);
        PrintStream out = System.out;
        // 设置一个对象便于查看内存地址
        EnumSingleton.INSTANCE.setData(new Object());
        executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));
        executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));
        executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));
        executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));
        executor.execute(() -> out.println(EnumSingleton.INSTANCE.getData()));
        executor.shutdown();
    }
}

测试成功可以保证单例代码简单非常优雅

第四种 Spring中的单例模式实现也可以称为容器化单例

大家可以通过idea搜索找到 Spring 源码中的 DefaultSingletonBeanRegistry 类 getSingleton 方法查看 Spring 是如何编写的

这里涉及到三个单例容器：

singletonObjects
earlySingletonObjects
singletonFactories

单例的获取顺序是singletonObjects -> earlySingletonObjects -> singletonFactories 这样的三级缓存

我们发现，在 singletonObjects 中获取 bean的时候，没有使用 synchronized 关键字

而在 singletonFactories 和 earlySingletonObjects 中的操作都是在 synchronized 代码块中完成的，正好和他们各自的数据类型对应

singletonObjects 使用的使用 ConcurrentHashMap 线程安全，而 singletonFactories 和 earlySingletonObjects 使用的是 HashMap 线程不安全。

从字面意思来说：singletonObjects 指单例对象的缓存，singletonFactories 指单例对象工厂的缓存，earlySingletonObjects 指提前曝光的单例对象的缓存。

以上三个构成了三级缓存，Spring 就用这三级缓存巧妙的解决了循环依赖问题。

除了这三个缓存之外最核心的就是上面讲到的 双重校验单例 写法

第五种特殊单例线程单例

顾名思义保证在所有线程内的单例

常见使用场景日志框架确保每个线程内都有一个单例日志实例保证日志记录和输出的唯一性

提到线程我们肯定会想到在线程内最常使用的东西那就是 TheadLocal 他可以保证线程之间的变量隔离我们就基于他来实现线程单例

public class ThreadLocalSingleton {
    // 通过 ThreadLocal 的初始化方法 withInitial 初始化对象实例 保证线程唯一
    private static final ThreadLocal<ThreadLocalSingleton> threadLocaLInstance =
            ThreadLocal.withInitial(() -> new ThreadLocalSingleton());

    private ThreadLocalSingleton(){}

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

测试用例与运行结果

/**
 * @author LionLi
 */
public class Test {
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(5);
        PrintStream out = System.out;
        executor.execute(() -> {
            out.println(ThreadLocalSingleton.getInstance());
            out.println(ThreadLocalSingleton.getInstance());
        });
        executor.execute(() -> {
            out.println(ThreadLocalSingleton.getInstance());
            out.println(ThreadLocalSingleton.getInstance());
        });
        executor.shutdown();
    }
}