Android设计模式(1)——单例模式

earnest_er
1,471 阅读3分钟

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

单例模式使用的场景

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型对象只应该有且只有一个，例如，创建一个对象需要消耗的资源过多，，如要访问IO和数据库等资源，这时就需要考虑使用单例模式。

单例模式的UML类图

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

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

示例

示例类图： 示例实现代码

//普通员工类
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();
    //构造函数私有化
    private CEO(){}
    //公有的静态函数，对外暴露获取单例对象的接口
    public static CEO getInstance(){
    	return mCeo;
    }
    @Override
    public void work(){
    	//管理VP
    }
}

//公司类
public class Company{
	private List<Staff> allStaffs = new ArrayList<>();
    public void addStaff(Staff staff){
    	allStaffs.add(staff);
    }
    public void showAllStaffs(){
    	for (Staff staff : allStaffs){
        	System.out.println("Obj:" + staff.toString());
        }
    }
}

//场景类
public class Client{
	public static void main(String[] args){
    	Company cp = new Company();
        Staff ceo1 = CEO.getInstance();
        Staff ceo2 = CEO.getInstance();
        Staff vp1 = new VP();
        Staff vp2 = new VP();

        Staff staff1 = new Staff();
        Staff staff2 = new Staff();

        cp.addStaff(ceo1);
        cp.addStaff(ceo2);
        cp.addStaff(vp1);
        cp.addStaff(vp2);
        cp.addStaff(staff1);
        cp.addStaff(staff2);

        cp.showAllStaffs();
    }
}

结果：
Obj:com.zxf.srp.company.CEO@45ee12a7
Obj:com.zxf.srp.company.CEO@45ee12a7
Obj:com.zxf.srp.company.VP@330bedb4
Obj:com.zxf.srp.company.VP@2503dbd3
Obj:com.zxf.srp.company.Staff@4b67cf4d
Obj:com.zxf.srp.company.Staff@7ea987ac

从上述的代码中可以看到，CEO类不能通过 new 的形式构造对象，只能通过CEO.getInstance()函数来获取，而这个CEO对象是静态对象，并且在声明的时候就已经初始化，这就保证了CEO对象的唯一性，从输出结果中发现，CEO两次输出的对象都是一样的，而VP,Staff对象都是不同的，这个实现的核心在于将类的构造函数私有化，使得外部程序不能通过构造函数来构造CEO对象，而CEO类通过一个静态方法返回一个静态对象。

单例模式的其他实现方式

  • 懒汉模式 懒汉模式是声明一个静态对象，并且在用户第一次调用getInstance时进行初始化，而上诉的饿汉模式是在声明静态对象就已经初始化了，懒汉模式单例模式实现如下：
public class Singleton{
	private static Singleton mInstance;
    private Singleton;
    public static synchronized Singleton getInstance(){
    	if(mInstance == null){
        	mInstance = new Singleton();
        }
        return mInstance;
    }
}

上述代码，getInstance() 方法中添加了synchronized关键字，也就是getInstance()是一个同步方法，这就是上面所说的多线程情况下保证单例对象唯一性的手段，但是这样会有一个问题，instance已经被初始化，每次调用getInstance()方法都会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大的问题。 懒汉模式只有在使用的时候才会被实例化，在一定程度上节约了资源，缺点是第一次加载时需要及时进行初始化，反应稍慢，最大的问题是每次调用getInstance()都进行同步，造成不必要开销，这种模式一般不建议使用。

  • Double Check Lock(DCL) 双重锁检查 DCL方式实现单例模式的有点是既能够在需要时才初始化实例，有能够保证线程安全，且单例对象初始化调用getInstance不进行同步锁。代码如下：
public class Singleton{
	private static Singleton mInstance;
    private Singleton(){}
    public static Singleton getInstance(){
    	if(mInstance == null){
        	synchronized(Singleton.class){
            	if(mInstance == null){
                	mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }
}

上述代码可以看到getInstance()中对mInstance进行了两次潘孔，第一层判断主要是为了避免不必要的同步，第二层判断是为了在null的情况下创建实例。 线程的执行顺序：假设线程A执行到 mInstance = new Singleton()语句，这里看起来是一句语句，但实际上他并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了三件事：

  1. 给Singleton的实例分配内存
  2. 调用Singleton构造函数，初始化成员字段
  3. 将sInstance对象指向分配的内存空间 但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JVM中Cche、寄存器允许处理乱序执行，上面的第二和第三的殊勋是无法保证的，也就是说，执行顺序可能是1-2-3，也可能是1-3-2，如果是后者，并且在3执行完毕，2未执行之前，被切到B线程上，这时候sInstance因为已经在线程A执行过了第三点，mInstance已经是非空了，所有线程B直接取走mInstance，在使用时就会出错，这就是DCL失效问题。

在JDK1.5之后SUN官方已经注意到了这个问题，调整了JVM，具体化了volatile关键字，因此如果是JDK1.5或之后的版本，只需要将mInstance的定义改成 private volatile static Singleton mInstance, 就可以保证mInstance对象每次都是从主内存中读取，保证了对象的唯一性。加上volatile会或多或少影响到程序的性能，但是为了保证程序的正确性，牺牲这点性能只值得的。

DCL的优点：资源利用率高。缺点：第一次加载反应稍慢，也由于Java内存模型的原因会偶尔失败，在高并发的环境下也有一定的缺陷。DCL模式是使用最多的单例实现方式，它在需要的时候才实例化单例，并且能在绝大多数场景下单证对象的唯一性。

  • 静态内部类单例模式 DCL虽然在一定程度上解决了资源消耗，多余的同步，线程安全等问题，但是，它在某些情况下还是会出现失效的问题，这个问题被称为双重检查锁(DCL)失效，在《Java并发编程实践》一书的最后谈到了这个问题，并指出这种 “优化” 是丑陋的，不赞成使用，而建议使用如下的代码替代。
public class Singleton{
	private Singleton{}
    public static Singleton getInstance(){
    	return SingletonHolder.mInstance();
    }
    //静态内部类
    private static class SingletonHolder{
    	private static final Singleton mInstance = new Singleton();
    }
}

第一次加载时Singleton类时并不会初始化mInstance，只有在第一次调用Singleton的getInstance()时才会导致mInstance被初始化，因此，第一次调用getInstance()会导致虚拟机加载SingletonHolder类，这种方式不仅能保证线程安全，也能保证单例对象的唯一性，同时也延迟了单例的初始化，所有这是推荐使用的单例实现方式。

  • 枚举单例 之前讲到的单例模式实现方式不是稍显麻烦就是会在某些情况下出现问题。枚举单例是更简单的实现方式，代码如下：
public enum SingletonEnum{
	INSTANCE;
    public void doSomething(){
    	System.out.println("do sth.");
    }
}

写法简单是枚举单例最大的有点，枚举在Java中与普通的类是一样的，不仅能够有字段，还能有自己的方法，最重要的是枚举实例默认是线程安全的，并且在任何情况下它都是一个单例。在上述的几种单例实现中，在反序列化的情况下他们会重新创建对象。

我们知道通过序列化可以讲一个单例的实例对象写到磁盘，然后在读回来，从而有效的获得一个实例，即使构造函数是私有的，反序列化依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数，反序列化提供了一个很特别的钩子函数，类中具有一个私有的readResolve()函数，这个函数可以让开发人员控制对象的反序列化。例如在上诉几个示例中，如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入readResolve函数。

public class Singleton{
	private Singleton{}
    public static Singleton getInstance(){
    	return SingletonHolder.mInstance();
    }
    //静态内部类
    private static class SingletonHolder{
    	private static final Singleton mInstance = new Singleton();
    }
    private Object readResolve() throws ObjectStreamException{
    	return mInstance;
    }
}

也就是在readResolve方法中将单例对象返回，而不是重新生成一个对象，而对于枚举则不存在这个问题，因为即使反序列化它也不会重新生成新的实例，另外还有两点需要注意：

  1. 可序列化类中的字段类型不是Java的内置类型，那么该字段类型也需要实现Serializable接口
  2. 如果你调整了可序列化类的内部结构，例如新增字段、去除某个字段，但没有修改SerialVersionID,那么就会引发 "java.io.JnvalidClassException" 异常或者导致某个属性为0或者null，此时最好的方案是我们直接将SerialVersionID 设置为0L，这样即使修修改了类的内部结构，我们反序列化也不会抛出异常，只是那些字段会为0或者null。
  • 使用容器实现单例模式 具体代码如下：
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);	
    }
}

在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对应类型的对象，这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

不管以哪种形式实现单例模式，他们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取过程中必须保证线程安全、放置反序列化导致重新生成实例对象等问题，选择哪种实现方式取决项目本身。

总结：

优点

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

缺点：

  1. 单例模式一般没有借口，扩展很困难，若要扩展，除了修改代码基本没有第二种选择。
  2. 单例对象如果持有Context，那么很容易引发内存泄露，此时需要注意传给单例对象的Context最好是ApplicationContext

《Android源码设计模式解析与实战》

PS：觉得文章不还错的话可以添加公众号关注下，文章都会同步到公众号。

avatar
文章
阅读
粉丝