应用最广的模式——单例模式

作者: 程序员丶星霖 | 来源:发表于2019-01-08 23:50 被阅读14次

    《Android源码设计模式解析与实战》读书笔记(二)
    《Android源码设计模式解析与实战》PDF资料下载

    一、单例模式介绍

    单例模式是应用最广的模式之一。在应用这个模式时,单例对象的类必须保证只有一个实例存在。很多时候整个系统只需要拥有一个全局对象,这样有利于我们协调系统整体的行为。

    1.1、单例模式的定义

    确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

    1.2、单例模式的使用场景

    确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象只应该有且只有一个。

    实现单例模式主要有如下几个关键点

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

    通过将单例类的构造函数私有化,使得不能通过new的形式手动构造单例类的对象。单例类会暴露一个公有静态方法,需要调用这个静态方法获取到单例类的唯一对象,在获取这个单例对象的和过程中需要确保线程安全,即在多线程环境下构造单例类的对象也是有且只有一个,这也是单例模式实现中比较困难的地方。

    二、单例模式的简单示例(饿汉式单例模式)

    单例模式是设计模式中比较简单的,只有一个单例类,没有其他的层次结构与抽象。

    该模式需要确保该类只能生成一个对象,通常是该类需要消耗较多的资源或者没有多个实例的情况。

    请看下面示例。
    一个公司可以有几个VP、无数个员工,但是CEO只有一个。

    //普通员工
    public class Staff {
        public void work(){
            //工作
        }
    }
    
    
    
    //副总裁
    public class VP extends Staff{
    
        @Override
        public void work() {
            //管理下面的经理
        }
    }
    
    //CEO,饿汉式单例模式
    public class CEO extends Staff {
        private static final CEO mCeo = new CEO();
    
        //构造函数私有
        public CEO() {
        }
    
        //公有的静态函数,对外暴露获取单例对象的接口
        public static CEO getCeo() {
            return mCeo;
        }
    
        @Override
        public void work() {
            //管理VP
        }
    }
    
    //公司类
    public class Company {
        private List<Staff> allStaffs=new ArrayList<Staff>();
    
        public void addStaff(Staff per) {
            allStaffs.add(per);
        }
        public void showAllStaffs(){
            for (Staff per :
                    allStaffs) {
                Log.e("TAG","Obj:" + per.toString());
            }
        }
    }
    
     private void init() {
            Company cp=new Company();
            //CEO对象只能通过getCeo函数获取
            Staff ceo1 = CEO.getCeo();
            Staff ceo2 = CEO.getCeo();
            cp.addStaff(ceo1);
            cp.addStaff(ceo2);
    
            //通过new创建VP对象
            Staff vp1 = new VP();
            Staff vp2 = new VP();
    
            //通过new创建Staff对象
            Staff mStaff1 = new Staff();
            Staff mStaff2 = new Staff();
            Staff mStaff3 = new Staff();
    
            cp.addStaff(vp1);
            cp.addStaff(vp2);
            cp.addStaff(mStaff1);
            cp.addStaff(mStaff2);
            cp.addStaff(mStaff3);
    
            cp.showAllStaffs();
        }
    

    输出结果如下:

    2019-01-07 23:13:26.925 5313-5313/? E/TAG: Obj:com.tengxin.mytest.CEO@4c4ca4b
    2019-01-07 23:13:26.926 5313-5313/? E/TAG: Obj:com.tengxin.mytest.VP@e6f2c28
    2019-01-07 23:13:26.926 5313-5313/? E/TAG: Obj:com.tengxin.mytest.VP@3ba2d41
    2019-01-07 23:13:26.926 5313-5313/? E/TAG: Obj:com.tengxin.mytest.Staff@15542e6
    2019-01-07 23:13:26.926 5313-5313/? E/TAG: Obj:com.tengxin.mytest.Staff@f93c027
    2019-01-07 23:13:26.926 5313-5313/? E/TAG: Obj:com.tengxin.mytest.Staff@b9ee2d4
    

    从代码中可以看到,CEO类不能通过new的形式构造对象,只能通过CEO.getCEO()函数来获取。
    这个实现的核心在于量CEO类的构造方法进行了私有化,使得外部程序不能通过构造函数来构造CEO对象,而CEO类通过一个静态方法返回一个静态对象。

    三、单例模式的其他实现方式

    3.1、懒汉式单例模式

    懒汉式单例模式是声明一个静态对象,并且在用户第一次调用getInstance时进行初始化;而饿汉式单例模式是在声明静态对象时就已经初始化。

    懒汉式单例模式实现如下:

    //懒汉式单例模式
    public class Singleton {
        private static Singleton instance;
    
        private Singleton() {}
    
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    

    getInstance()方法中添加了synchronized关键字,使得在多线程情况下保证单例对象唯一。

    但是懒汉式单例模式也存在一个问题,就是每次调用getInstance方法都会进行同步,这样会消耗不必要的资源。

    懒汉式单例模式总结

    • 优点:单例只有在使用时才会被实例化,在一定程度上节约了资源;
    • 缺点:第一次加载时需要及时进行实例化,反应稍慢,最大的问题是每次调用getInstance都进行同步,造成不必要的同步开销。

    3.2、Double Check Lock(DCL)实现单例

    DCL方式实现单例模式的优点是既能够在需要时初始化单例,又能够保证线程安全,且单例对象初始化后调用getInstance不进行同步锁

    代码如下:

    //DCL方式实现单例模式
    public class DCLSingleton {
        private static DCLSingleton mSingleton = null;
    
        public DCLSingleton() {}
    
        public void doSomething(){
            Log.e("TAG", "do sth.");
        }
    
        public static DCLSingleton getInstance(){
            if (mSingleton == null) {
                synchronized (DCLSingleton.class) {
                    if (mSingleton == null) {
                        mSingleton = new DCLSingleton();
                    }
                }
            }
            return mSingleton;
        }
    }
    

    这种方式的亮点就在getInstance方法上,getInstance方法对mSingleton进行了两次判空:

    1. 第一层判断主要是为了避免不必要的同步;
    2. 第二层的判断是为了在null的情况下创建实例。

    DCL总结:

    • 优点:资源利用率高,第一次执行getInstance时单例对象才会被实例化,效率高。
    • 缺点:第一次加载时反应稍慢,也由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷。

    3.3、静态内部类单例模式

    DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题,但是,它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定(DCL)失效。

    建议使用如下代码:

    //静态内部类单例模式
    public class Singleton {
        private Singleton() {}
    
        public static Singleton getInstance(){
            return SingletonHolder.sInstance;
        }
    
        /**
         * 静态内部类
         */
        private static class SingletonHolder{
            private static final Singleton sInstance =new Singleton();
        }
    }
    

    当第一次加载Singleton类时并不会初始化sInstance,只有在第一次调用Singleton的getInstance方法时才会导致sInstance被初始化。

    这种方式不仅能够确保线程安全,也能够保证单例对象的唯一性,同时也延迟了单例的实例化,这是推荐使用的单例模式实现方式。

    3.4、枚举单例

    //枚举单例
    public enum SingletonEnum {
        INSTANCE;
        public void doSomething(){
            Log.e("TAG", "doSomething " );
        }
    }
    

    枚举单例最大的优点就是写法简单,枚举在Java中与普通的类是一样的,不仅能够有字段,还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的,并且字啊任何情况下它都是一个单例。

    通过序列化可以将一个单例的实例对象写到磁盘,然后再读回来,从而有效地获得一个实例。即使构造函数是私有的,反序列化时依然可以通过特殊的途径去创建类的一个新的实例,相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数,类中具有一个私有的、被实例化的方法readResolve(),这个方法可以控制对象的反序列化。上述几个示例中要杜绝单例对象在被反序列化时重新生成对象,必须加入如下方法:

        private Object readResolve() throws ObjectStreamException {
            return mSingleton;
        }
    

    而对于枚举,并不存在这个问题,因为即使反序列化也不会重新生成新的实例。

    3.5、使用容器实现单例模式

    下面是一种另类的实现:

    //使用容器实现单例模式
    public class SingletonManager {
    
        private static Map<String, Object> objMap = new HashMap<>();
    
        private SingletonManager() {}
    
        public static void registerService(String key,Object instance){
            if (!objMap.containsKey(key)) {
                objMap.put(key, instance);
            }
        }
    
        public static Object getService(String key) {
            return objMap.get(key);
        }
    }
    

    这种方式可以管理多种类型的单例,并且在使用时可以通过统一的接口进行获取操作,降低了用户的使用成本,也对用户隐藏了具体实现,降低了耦合度。

    无论什么形式实现单例模式,其核心原理都是将构造函数私有化,并且通过静态方法获取一个唯一的实例,在获取的过程中要保证线程安全、防止反序列化导致重新生成实例对象等问题。

    四、总结

    单例模式是运用频率很高的模式,在客户端通常没有高并发的情况下,选择哪种实现方式并不会有太大的影响。出于效率考虑,推荐使用DCL形式单例模式、静态内部类单例模式。

    4.1、优点

    1. 由于单例模式在内存中只有一个实例,减少了内存开支,特别是一个对象需要频繁地创建、销毁时,而且创建或销毁时性能又无法优化,单例模式的优势就非常明显;
    2. 由于单例模式只生产一个实例,所以,减少了系统的性能开销,当一个对象的产生需要比较多的资源时,则可以通过在应用启动时直接产生一个单例对象,然后用永久驻留内存的方式来解决;
    3. 单例模式可以避免对资源的多重占用,例如一个写文件操作,由于只有一个实例存在内存中,避免对同一个资源文件的同时写操作;
    4. 单例模式可以在系统设置全局的访问点,优化和共享资源访问,例如,可以设计一个单例类,负责所有数据表的映射处理。

    4.2、缺点

    1. 单例模式一般没有接口,扩展很困难,若要扩展,除了修改代码基本上没有第二种途径可以实现;
    2. 单例对象如果持有Context,那么很容易引发内存泄漏,此时需要注意传递给单例对象的Context最好是Application Context。

    学海无涯苦作舟

    我的微信公众号

    相关文章

      网友评论

        本文标题:应用最广的模式——单例模式

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