0
点赞
收藏
分享

微信扫一扫

几个直击灵魂的Spring拷问(六)

一叶轻舟okok 2021-09-24 阅读 69

单例模式可能是开发中应用最为广泛的一种的设计模式,Spring 中依赖注入 Bean 实例默认是单例的,在Netty开发的处理器很多也都是单例模式,另外许多的缓存数据持有者也是设置为单例模式,用上单例模式的好处是:1、可以保证内存里只有一个实例,减少了内存的开销。2、可以避免对资源的多重占用。3、单例模式设置全局访问点,可以优化和共享资源的访问。单例模式的特点,也是写单例代码的几个准则:

  • 构造函数不对外开放,一般为private。
  • 通过一个静态方法或者枚举返回单例类对象。
  • 确保单例类的对象有且只有一个,尤其在多线程情况下。
  • 确保单例类对象在反序列化时不会重新构建对象

首先看自己怎么写好一个单例模式,然后再来对照着看Spring的实现。

一、JDK的单例模式

1、饿汉式

这种是在类加载时就完成了初始化,所以类加载较慢,但获取对象的速度快。

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

2、懒汉式

该模式的特点是类加载时没有生成单例,只有当第一次调用 getlnstance 方法时才去创建这个单例。懒汉式的方式通常要考虑线程安全问题,为何呢?因为可能存在多个线程同时去调用 getlnstance 方法,而实例对象并未准备好需要去执行 new 操作。因此需要 Double Check Lock(DCL)双重校验锁来保证线程安全,第一层判断主要是为了判断是否存在,第二层判空是为了在null情况下创建实例。因此会有一个双重校验锁风格的代码:

//第一层判断主要是为了避免不必要的同步
if (instance == null) {
    synchronized (Singleton.class) {
        //第二层判空是为了在null情况下创建实例
        if (instance == null) {
            instance = new Singleton();
        }
    }
}

再来看new Singleton()操作并不是原子的,要分为三个步骤:

  • 分配一块内存 M;
  • 在内存 M 上初始化 Singleton 对象;
  • 然后 M 的地址赋值给 instance 变量。

由于Java编译器允许处理器乱序执行,上述顺序2、3是不能保证的,可能是1-2-3也可能是1-3-2;如果是后者,3执行了已经非空,再走2会出现问题,这就是DCL失效(线程B刚好执行到第一次判断instance==null,此时不为空,不用进入synchronized里,就将还未初始化的instance返回了)。要解决的话只需要加上volatile关键字,如上述代码操作就可以保证instance对象每次都是从主内存中读取的,就可以采用DCL来完成单例模式了。当然,volatile或多或少会影响到性能,但考虑到程序的正确性,牺牲点性能还是值得的。

private volatile static DCLSingleton instance = null;

所以一个最终版的双重校验锁单例代码案例为:

public class DCLSingleton {
    //Double Check Lock单例模式
    private volatile static DCLSingleton instance = null;

    private DCLSingleton() {
    }

    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

3.反射和序列化攻击破坏单例

上面已经举例了恶汉、懒汉、DSL类型,当然还有静态内部类的实现方式,但是这些方法都有个共同的特点——私有的构造函数。这是为了防止在该类的外部直接调用构建函数创建对象了。但是该做法却无法防御反射攻击,比如我们可以通过反射拿到构造方法,通过调用 newInstance 方法进行破坏:

public class ReflectAttack {
    public static void main(String[] args) throws Exception {
        //获取无参的构造函数
        Singleton instance = Singleton.getInstance();
        //使用构造函数创建对象
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton reflectInstance = constructor.newInstance();
        System.out.println(instance==reflectInstance);
    }
}

序列化攻击,先将得到的实例对象进行序列化得到字节数组,然后在进行反序列化就可以得到一个新的对象,这个对象已经和原来的对象不一样了。

public class DeserializeAttack {

    public static void main(String[] args) throws Exception {
        Singleton instance = Singleton.getInstance();
        byte[] bytes = serialize(instance);
        Object deserializeInstance = deserialize(bytes);
        System.out.println(instance == deserializeInstance);//运行为false
    }
    private static byte[] serialize(Object object) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(object);
        byte[] bytes = baos.toByteArray();
        return bytes;
    }
    private static Object deserialize(byte[] bytes) throws Exception {
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bais);
        return ois.readObject();
    }
}

4.枚举单例

《Effective Java》中有被提到:单元素的枚举类型已经成为实现 Singleton 的最佳方法。为啥枚举能杜绝上面的反射和序列化攻击呢?1、在枚举中构造方法已被限制为私有,2、在调用构造方法时,我们的单例被实例化,enum中的实例被保证只会被实例化一次,所以我们的INSTANCE也被保证实例化一次。

class Resource{
}
 
public enum SomeThing {
    /**
     * 枚举实例默认就是final static类型
     */
    INSTANCE;
    private Resource instance;
    /**
     * 枚举的构造方法默认就是private的
     */
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

二、Spring中的单例模式

Spring 依赖注入 Bean 实例默认是单例的。Spring 的依赖注入(包括 lazy-init 方式)都是发生在 AbstractBeanFactory 的 getBean 里。getBean 的 doGetBean 方法调用 getSingleton 进行 bean 的创建。

//AbstractBeanFactory#getSingleton()方法

public Object getSingleton(String beanName){
    //参数true设置标识允许早期依赖
    return getSingleton(beanName,true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        //如果为空,则锁定全局变量并进行处理。
        synchronized (this.singletonObjects) {
            //如果此bean正在加载,则不处理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                //当某些方法需要提前初始化的时候则会调用addSingleFactory 方法
                //将对应的ObjectFactory初始化策略存储在singletonFactories
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //调用预先设定的getObject方法
                    singletonObject = singletonFactory.getObject();
                    //记录在缓存中,earlysingletonObjects和singletonFactories互斥
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

spring 依赖注入时,可以看到是使用了 双重判断加锁的单例模式

參考引用

微信文章源码分析:为什么枚举是单例模式的最佳方法

举报

相关推荐

0 条评论