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

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

1、单例模式介绍

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

1.一、单例模式的定义

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

1.二、单例模式的使用场景

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

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

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

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

2、单例模式的简单示例（饿汉式单例模式）

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

该模式须要确保该类只能生成一个对象，一般是该类须要消耗较多的资源或者没有多个实例的状况。

请看下面示例。 一个公司能够有几个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、单例模式的其余实现方式

####3.一、懒汉式单例模式

懒汉式单例模式是声明一个静态对象，而且在用户第一次调用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.二、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.三、静态内部类单例模式

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.四、枚举单例

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

枚举单例最大的优势就是写法简单，枚举在Java中与普通的类是同样的，不只可以有字段，还可以有本身的方法。最重要的是默认枚举实例的建立是线程安全的，而且字啊任何状况下它都是一个单例。

经过序列化能够将一个单例的实例对象写到磁盘，而后再读回来，从而有效地得到一个实例。即便构造函数是私有的，反序列化时依然能够经过特殊的途径去建立类的一个新的实例，至关于调用该类的构造函数。反序列化操做提供了一个很特别的钩子函数，类中具备一个私有的、被实例化的方法readResolve()，这个方法能够控制对象的反序列化。上述几个示例中要杜绝单例对象在被反序列化时从新生成对象，必须加入以下方法：

private Object readResolve() throws ObjectStreamException {
        return mSingleton;
    }
复制代码

而对于枚举，并不存在这个问题，由于即便反序列化也不会从新生成新的实例。

3.五、使用容器实现单例模式

下面是一种另类的实现：

//使用容器实现单例模式
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);
    }
}
复制代码

这种方式能够管理多种类型的单例，而且在使用时能够经过统一的接口进行获取操做，下降了用户的使用成本，也对用户隐藏了具体实现，下降了耦合度。

不管什么形式实现单例模式，其核心原理都是将构造函数私有化，而且经过静态方法获取一个惟一的实例，在获取的过程当中要保证线程安全、防止反序列化致使从新生成实例对象等问题。

4、总结

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

4.一、优势

1. 因为单例模式在内存中只有一个实例，减小了内存开支，特别是一个对象须要频繁地建立、销毁时，并且建立或销毁时性能又没法优化，单例模式的优点就很是明显；
2. 因为单例模式只生产一个实例，因此，减小了系统的性能开销，当一个对象的产生须要比较多的资源时，则能够经过在应用启动时直接产生一个单例对象，而后用永久驻留内存的方式来解决；
3. 单例模式能够避免对资源的多重占用，例如一个写文件操做，因为只有一个实例存在内存中，避免对同一个资源文件的同时写操做；
4. 单例模式能够在系统设置全局的访问点，优化和共享资源访问，例如，能够设计一个单例类，负责全部数据表的映射处理。

4.二、缺点

1. 单例模式通常没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径能够实现；
2. 单例对象若是持有Context，那么很容易引起内存泄漏，此时须要注意传递给单例对象的Context最好是Application Context。

学海无涯苦做舟