美文网首页
单例模式的几种写法和对比

单例模式的几种写法和对比

作者: 蓝灰_q | 来源:发表于2017-10-12 19:45 被阅读79次

    1.饿汉
    private static Singleton instance=new Singleton();

    private static Singleton instance=null;
    static {
    instance=new Singleton();
    }
    其实就是在类加载时,准备阶段里把类的属性实例化,缺点是可能提前加载到内存。
    2.线程不安全的懒汉
    private static Singleton instance;
    其实就是没有任何锁,用的时候再去判断并初始化,有可能在判断为空和执行初始化期间,别的线程完成了初始化
    3.线程安全的懒汉
    private static Singleton instance;
    public synchronized Singleton getInstance(){}
    其实就是为静态方法加了类锁,凡是用这个静态函数的,一律加锁,缺点就是锁阻塞,影响效率
    4.双重校验锁
    private volatile static Singleton instance;
    private void Singleton(){}
    public static Singleton getInstance(){
    if(instance==null){
    synchronized(Singleton.class){
    if(instance==null){
    instance=new Singleton();
    }
    }
    }
    }
    用synchronized来实现锁同步的实例化,因为获取锁之后会更新一次数据,所以要再检查一次instance是否为空
    注意,使用volatile主要是为了实现有序性,instance=new Singleton();实际上是3个指令(分配内存+实例化+指向引用),有可能遇到指令重排序导致出错的问题,volatile会通过内存屏障,禁止重排序,顺便可以用来实现可见性,减少资源消耗。
    5.静态内部类
    private static class SingletonHolder{
    private static final Singleton instance=new Singlton();
    }
    public static Singleton getInstance(){
    return SingletonHolder.instance;
    }
    private void Singlton(){}
    其实就是利用类的主动加载机制,只有在使用到静态类的对象时,才去加载类,这样静态内部类一定是在getInstance时加载。
    另外,静态对象虽然天然只有方法区的一个实例,但也有被修改的可能,所以用final确保线程安全。
    静态内部类相比内部类来说,不能直接调用宿主类的函数,但是也拥有内部类的访问权限,所以不受private限制
    6.枚举
    public enum EnumSingleton{
    INSTANCE;
    private Singleton instance;
    private EnumSingleton(){
    instance=new Singleton();
    }
    public Singleton getInstance(){
    return instance;
    }
    }
    其实就是因为枚举类型是static final类型,而且只能实例化一次,原理上其实和静态内部类的写法一样。
    单元素的枚举类型已经成为实现Singleton的最佳方法。
    多个classloader破坏单例
    不同classloader加载的类不是同一个类,所以要避免多个classloader加载出多个单例对象。
    这种情况下,可以考虑用当前线程的ClassLoader来加载类。
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    反射破坏单例
    因为反射可以拿到constructor构造函数,所以调用构造函数的newInstance方法能破坏单例:

    //获得构造器
    Constructor con = Singleton.class.getDeclaredConstructor();
    //设置为可访问
    con.setAccessible(true);
    //构造新的对象
    Singleton singleton1 = (Singleton)con.newInstance();
    

    对于需要构造函数的单例写法来说,因为只是在正常情况下屏蔽了构造函数,所以可以用反射访问到构造函数,破坏单例;
    只有枚举单例不能被反射破坏,因为枚举单例在编译后,其实是abstract类,无法初始化,而且Java在newInstanc时对Enum禁止。
    反序列化破坏单例
    如果单例是可序列化的,就很容易通过反序列化得到多个单例对象。因为ObjectInputStream的readResolve函数会反射执行构造函数,绕过单例的代码限制机制。
    注意,枚举单例不能implement Serializable,否则readObject的特性“每次都返回新建的实例”会破坏单例。
    这种情况下,可以考虑修改readResolve函数,返回饿汉的静态单例对象。
    public static Singleton INSTANCE = new Singleton();
    private Object readResolve() {
    return INSTANCE;
    }
    构造函数报错
    根据Initialization-on-demand holder idiom的提示,使用内部静态类这种单利写法时,需要确保构造函数不抛异常,例如:

        private SingletonClass() {
            throw new RuntimeException("exception in constructor");
        }
    

    文章声称,这种情况会导致调用报错,NoClassDefFoundError。
    不过,当我们实际测试一下两次调用,会发现两次报错不一样:
    第一次报错其实是ExceptionInInitializerError,这是因为第一次调用SingletonClass.getInstance()时,需要加载目标类(懒加载),在加载过程中,执行构造函数失败,所以报错会是ExceptionInInitializerError。
    第二次报错因为第一次加载类失败,类只会加载一次,而第一次的加载过程失败了,所以会报NoClassDefFoundError,找不到目标类。

    单例模式的七种写法
    为什么要用枚举实现单例模式(避免反射、序列化问题)
    Java transient关键字使用小记

    相关文章

      网友评论

          本文标题:单例模式的几种写法和对比

          本文链接:https://www.haomeiwen.com/subject/zozwyxtx.html