3、Android设计模式---（应用最广的设计模式）单例模式

一、介绍，定义

单例对象的类必须保证只有一个实例存在。许多时候系统只需要拥有一个全局对象，这样有利于我们协调整个系统整体行为。如ImageLoader实例，包含线程池、缓存系统、网络请求等，很耗资源，没有理由让他构造很多实例。

二、使用场景

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

三、单例模式UML类图

1.png

Client---高层客户端
Singleton---单例类

实现单例类有以下几个关键点：
1、构造函数不对外开放，一般为Private；（客户端不能通过new的形式手动构造单例对象）
2、通过一个静态方法或者枚举类型返回单例类对象；
3、确保单例类的对象有且仅有一个，尤其是在多线程环境下；
4、确保单例类对象在反序列化时不会重新构建对象。

四、一个简单示例（饿汉模式---声明对象时就已经初始化）

public class Singleton {
  private static Singleton instance = new Singleton()；
  //构造函数私有
  private Singleton(){};
  //公有静态函数，对外暴露获取单例对象的接口
  public static Singleton getInstance(){
    return instance;
  }
}

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

5.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()方法中添加了synchonized关键字，也就是变成了同步方法，在多线程下保证单例对象唯一性的手段。
优点：单例只有在使用时才会被实例化。
缺点：第一次加载时要及时进行实例化；每次调用getInstance()都进行同步，造成不必要的开销，这种模式一般不建议使用。

5.2Double Check Lock（DCL）实现单例

public class Singleton {
  private static Singleton instance =null；
  private Singleton(){};

  public static synchronized Singleton getInstance(){
    if(instance == null){
      synchonized(Singleton.class){
        if(instance== null){
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

第一次判空是为了避免不必要的同步，第二次判空是为了在null情况下创建实例。分析：
instance = new Singleton(); 一句代码分为三步操作：
1给Singleton实例分配内存；
2调用Singleton（）构造函数，初始化成员字段；
3将instance对象指向分配的内存空间（此时instance就不是null了）。
但由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（java memory model 即java内存模型）中cache，寄存器到主内存会写顺序的规定，上面可以使1-2-3或1-3-2，如果是后者，在3执行完，2未执行之前，切换到线程B上，instance已经是非空了，B直接取走instance，使用时就会出错，这就是DCL失效问题，而且难以追踪可能会隐藏很久。
JDK1.5之后，SUN调整了JVM，具体化了volatile关键字，只要改为：

 private volatile static Singleton instance =null；

即可保证instance对象每次都是从主内存中读取，就可以使用DCL写法来完成单例模式。当然volatile也会影响性能，但值得。

5.3静态内部类实现单例模式

DCL还是在某些情况下出现失效问题。被称为双重检查锁定（DCL）失效，在《Java并发编程实践》中谈到这个问题，并指出这种优化是丑陋的，不赞成使用，而建议用以下替代。

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

使用静态内部类能保证线程安全的原因：
1由于内部静态类只会被加载一次，故该实现方式是线程安全的
2类加载的初始化阶段是单线程的

当第一次加载Singleton类时不会初始化instance，只有调用时才会初始化。因为第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能确保线程安全，也能保证唯一性，同时也延迟了单例的实例化，所以这是推荐的单例模式实现方式。

5.4枚举实现单例模式

public enum SingletonEnum{
  INSTANCE;
  public void doSomeThing(){
    System.out.println("do sth.");
  }
}

一个简单应用demo

2.png

5.5使用容器实现单例

public class SingletonManager {
    private static Map<String,Object> map=new HashMap<String, Object>();
    
    private SingletonManager(){}
    
    public static void registerService(String key,Object instance){
        if (!map.containsKey(key)){
            map.put(key,instance);
        }
    }
    
    public static Object getService(String key){
        return map.get(key);
    } 
}

在程序的初始化，将多个单例类型注入到一个统一管理的类中，使用时通过key来获取对应类型的对象，这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行操作。

注意：单例模式一般没有接口，如果要修改，只能修改代码，很难扩展；如果持有Context容易内存泄漏，所以最好为ApplicationContext。