单例设计模式Singleton

2024-02-21 06:18:01
开发
45

1.模式定义

保证一个类只有一个实例，并且提供一个全局访问点

2.应用场景

重量级的对象，不需要多个实例，如线程池，数据库连接池。

2.1 源码中的应用

// Spring & JDK
java.lang.Runtime
org.springframework.aop.framework.ProxyFactoryBean
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
org.springframework.core.ReactiveAdapterRegistry
// Tomcat
org.apache.catalina.webresources.TomcatURLStreamHandlerFactory
// 反序列化指定数据源
java.util.Currency

3.实现方式

3.1 懒汉模式

延迟加载，只有在真正使用的时候，才开始实例化。

1）线程安全问题

2）double check 加锁优化

3）编译器(JIT),CPU 有可能对指令进行重排序，导致使用到尚未初始化

的实例，可以通过添加volatile 关键字进行修饰，

对于volatile 修饰的字段，可以防止指令重排。

public class LazySingletonTest {
    public static void main(String[] args) {
//        LazySingleton singleton = LazySingleton.getInstance();
//        LazySingleton singleton1 = LazySingleton.getInstance();
//        System.out.println(singleton == singleton1);

        Thread thread = new Thread(()->{
            LazySingleton s1 = LazySingleton.getInstance();
            System.out.println(s1);
        });
        thread.start();

        Thread thread2 = new Thread(()->{
            LazySingleton s1 = LazySingleton.getInstance();
            System.out.println(s1);
        });
        thread2.start();
    }
}


class LazySingleton{
    private volatile static LazySingleton singleton = null;
    private LazySingleton(){

    }

    public static LazySingleton getInstance(){
        // synchronized 不建议修饰在方法上，因为方法上每次调用都需要加锁，性能低
        if (singleton == null) {
            synchronized (LazySingleton.class){
                if (singleton == null) {
                    singleton = new LazySingleton();
                    //字节码
                    // 1.分配空间
                    // 2.初始化
                    // 3.引用赋值
                    // 初始化和引用赋值可以不分先后进行
                }
            }
        }
        return singleton;
    }
}

3.2.饿汉模式

类加载的初始化阶段就完成了实例的初始化。本质上就是借助于jvm

类加载机制，保证实例的唯一性（初始化过程只会执行一次）及线程安

全（JVM以同步的形式来完成类加载的整个过程）。

类加载过程：

1，加载二进制数据到内存中，生成对应的Class数据结构，

2，连接： a. 验证， b.准备（给类的静态成员变量赋默认值），c.解析

3，初始化：给类的静态变量赋初值

只有在真正使用对应的类时，才会触发初始化如（当前类是启动类即

main函数所在类，直接进行new 操作，访问静态属性、访问静态方

法，用反射访问类，初始化一个类的子类等.）

class HungerSingleton {
    private static HungerSingleton singleton = new HungerSingleton();

    private HungerSingleton() {

    }

    public static HungerSingleton getInstance() {
        return singleton;
    }
}

3.3 静态内部类

1).本质上是利用类的加载机制来保证线程安全

2).只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一

种形式。

class InnerClassSingleton {

    private InnerClassSingleton() {
    }

    private static class InnerClassHandle {
        private static InnerClassSingleton singleton = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance(){
        return InnerClassHandle.singleton;
    }
}

3.4 反射攻击实例

静态内部类防止反射破坏

原文地址:https://blog.csdn.net/xiangbiao2009/article/details/136196711 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1760066301235171328.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部