单例模式梳理

单例三要素
1.私有的构造函数
2.静态的对象实例
3.静态的获取对象的 方法

为了保证多线程安全,有三种解决方法

第一种:同步获取实例的方法

package com.test.single;

public class Single {

    private static Single instance;

    private Single() { }

    public static synchronized Single getInstacne() {
        if (null == instance) {

            instance = new Single();
        }
        return instance;
    }

}

点评:线程安全,但是性能差,每次在获取这个实例的时候都需要进行线程安全判断

第二种 双重检查

package com.test.single;

public class DoubleCheck {

    private volatile static DoubleCheck instance; //这里必须是volatile的,这样保证对象的可见性

    private DoubleCheck () {

    }

    public static DoubleCheck getInstance(){
        if (null == instance) {
            synchronized (DoubleCheck.class) { //具体这个地方的实现可以是多种多样的,也可以用LOCK
                if (null == instance) {
                    instance = new DoubleCheck();
                }
            }
        }
        return instance;
    }

}

点评:不需要每次去实例对象,在JDK1.5以前版本不能保证线程安全,存在JDK版本限制

第三种:懒汉式创建对象

package com.test.single;

public class LazySingle {

    private static LazySingle instance = new LazySingle();

    private LazySingle() { }

    public static  LazySingle getInstacne() {
        return instance;
    }
}

点评:直接在实例对象时,静态初始化,保证实例的唯一。但是在某些情况下,对象未被使用,且这个对象很大时,就会很消耗资源

对于这种懒汉式的做法还有个变种,用了一个静态内部类来保证实例的唯一

第四种:静态内部类

package com.test.single;

public class SingleInnner {

    private SingleInnner(){}

    static class InstanceHandle {
        static volatile  SingleInnner instance = new  SingleInnner();
    }

    public static  SingleInnner getInstacne() {
        return InstanceHandle.instance;
    }

}

点评:其实这种方式的出现早期是为了解决double-check的问题,其实本质上就是一个懒汉式的做法,还是在类加载时候初始化一个静态实例。玩个花哨而已,而且还变的更加复杂了,想比较第三中没有什么区别!仅仅当做参考而已!

单例中还需要注意的几个点:
1.单例的出现时为了解决在系统中只保证一个对象实例,但是使用的情况应该不多,若是太多的,就是设计存在问题!
2.若是存在多个类加载器的话,那么单例还是会失效
3.在JDK1.2中,还是会将单例对象回收,需要建立注册表
4.综合考虑性能和资源,选择合适的方案来解决多线程的问题,默认情况下,我们认为所有的场景都是多线程的!

常见单例实例场景:
线程池,缓存,注册表等!

作者: inter12

在这苦短的人生中,追求点自己的简单快乐

发表评论

电子邮件地址不会被公开。 必填项已用*标注