Android应用最广的模式-单例模式

      单例模式是应用最广的模式之一，也可能是大家最会使用的设计模式，在应用这个模式时，单例对象的类必须保证只有一个实例存在，而且自行实例化并向整个系统提供这个实例，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个，例如，创建一个对象需要消耗的资源过多，如要访问IO数据库等资源，这时就要考虑使用单例模式。

 优点：

   1.由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。

   2.由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留的方式来解决。

   3.单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

   4.单例模式可以在系统配置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

缺点：

   1.单例模式一般没有接口，拓展很困难，若要拓展，除了修改代码基本上没有第二种途径可以实现。

   2.单例对象如果持有Context，那么很容易引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context.

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

    1.构造函数不对外开放，一般为Private；

    2.通过一个静态方法或者枚举返回单例类对象；

    3.确保单例类的对象有且只有一个，尤其是在多线程环境下；

    4.确保单例类对象在反序列化时不会重新构建对象。

 实现方式：

    1.饿汉单例模式

     特点：在声明静态对象时就已经初始化，

//饿汉单例模式
public class Singleton{
     private static final Singleton mSingleton = new Singleton();
    //构造函数私有
    private Singleton(){
   }
   //公有的静态函数，对外暴露获取单例对象的接口
   public static Singleton getSingleton(){
       return mSingleton;
  }
}

  2.懒汉单例模式

   特点：单例只有在使用时才会被实例化，在一定程度上节约了资源，但第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。这种模式一般不建议使用。

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

 3.Double Check Lock(DCL)实现单例

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

//DCL单例模式
public class Singleton{
   private static Singleton sInstance = null;
   private Singleton (){

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

该方式实现单例的亮点在getInstance方法上，可以看到getInstance方法中对instance进行了两次判空；第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。这是什么意思呢？下面来分析一下。

 假设线程A执行到sInstanc = new Singleton（）语句，这里看起来是一句代码，但实际上它并不是原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事情：

  (1)..给Singleton的实例分配内存;

  (2).调用Singleton的构造函数，初始化成员字段；

  (3).将sInstance对象指向分配的内存空间(此时sInstance就不是null了)。

  但是，由于java编译器允许处理器乱序执行，以及JDK1.5之前JVM中Cache、寄存器到主内存回写顺序的规定，上面的第二和第三的顺序是无法保证的。也就是说，执行顺序可能是1-2-3也可能是1-3-2。如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候sInstance因为已经在线程A内执行过了第三点，sInstance已经是非空了，所以线程B直接取走sInstance，再使用时就回出错，这就是DCL失效问题。

  DCL的优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。

              缺点：第一次加载时反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发环境下有一定的缺陷，虽然发生概率很小。

 DCL模式是使用最多的单例实现方式，它能够在需要时才实例化单例对象，并且能够在绝大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK6版本下使用，否则这种方式一般能够满足需求。

 4.静态内部类单例模式

  特点：可以解决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被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SinletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。

总结：

  单例模式是运用频率很高的模式，但是，由于在客户端通常没有高并发的情况，因此，选择哪种方式并不会有太大的影响，即便如此，出于效率考虑，这里推荐3.DCL和4.静态内部类模式的使用形式。