Android设计模式之单例模式详解

单例模式是应用最广的模式之一。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。如在一个应用中，应该只有一个ImageLoader实例，这个ImageLoader中又包含有线程池，缓存系统，网络请求等，很消耗资源，因此，没有理由让它构造多个实例。这种不能自由构造对象的情况，就是单例模式的使用场景。

一、单例模式的定义

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

二、单例模式的使用场景

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

三、实现单例模式的关键点

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

四、实现单例模式的几种方式（代码示例）

1.饿汉式

特点：不需要同步，因为在类加载时已经初始化完毕，也不需要判断null，直接返回。饿汉式无需关注多线程问题、写法简单明了、能用则用。但是它是加载类时创建实例、所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载不管用不用都会把所有实例一块创建。一般不推荐使用，代码如下：

public class SingleClass {
    private static final SingleClass single = new SingleClass();
    private SingleClass(){}//构造函数私有化
    public static SingleClass getInstance(){
        return single;
    }
 }

2.懒汉式

特点：懒汉式是声明一个静态对象，并且在用户第一次调用getInstance()时进行初始化，相比饿汉式类加载时就初始化效率要高，但是懒汉式在多线程程环境下无法保证对象的唯一性，所以需要进行同步操作，但每次的同步操作同样也影响效率，代码如下：

public class SingleClass {
    private static SingleClass single = null;
    private SingleClass(){}
    public static synchronized SingleClass getInsgtance(){//同步
        if(single==null){
            single = new SingleClass();
        }
        return single;
    }
 }

3.双重检查索（Double Check Lock）（用的最多）

特点：进行了双重判断，弥补了懒汉式的缺点，代码如下：

public class SingleClass {
    private static SingleClass single = null;
    private SingleClass(){}
    public static SingleClass getInstance(){
        if(single==null){
            synchronized (SingleClass.class){
                if(single==null){
                    single = new SingleClass();
                }
            }
        }
        return single;
    }
 }

双重检索式应该是用得最多的一种单例模式，可以看到这里getInstance()方法中对single进行了两次判空：第一层判断比较容易理解，主要是为了避免不必要的同步，因为如果不进行第一层判断，那么每次调用getInstance()获取实例都需要进行一次同步操作，而判断过后只有在第一次调用getInstance()的时候需要进行同步，以后调用因为single已经不为null了，就直接返回single，避免了不必要的同步带来的开销。第二层判断是为了检查single 实例是否已经存在，即保证只创建一个对象。如果不进行第二层判断，那么当在多线程环境下，可能同时有多个线程进入到第一层判断后，然后同步等待创建了多个线程。
上面的双重检查锁看上去比较完美了，然而却是存在隐患的。因为single = new SingleClass()这行代码并不是一个原子操作，关于原子性等知识点可以参考Java并发编程：volatile关键字解析），这句代码最终会被编译成多条汇编指令，它大致做了3件事：
1. 给SingleClass的实例分配内存
2. 调用SingleClass()的构造函数，初始化成员字段
3. 将single对象指向分配的内存空间（此时single已经不为null）
但是由于Java编译器允许处理器乱序执行，导致上面的2，3的顺序无法保证，如果是3执行完毕，2未执行之前被切换到线程B上，这时候single因为已经在线程A内执行过了3，single已经不是null了，所以，线程B直接取走single，再使用时就会出错

针对这种情况，Java中可以使用volatile来修饰single，具体代码如下：

private static volatile SingleClass single = null;
    private SingleClass(){}
    public static SingleClass getInstance(){
        if(single==null){
            synchronized (SingleClass.class){
                if(single==null){
                    single = new SingleClass();
                }
            }
        }
        return single;
    }

由于volatile既可以保证有序性又可以保证可见性，所以看到很多文章甚至一些书本在双重检查锁中说使用volatile是保证了可见性，即保证single对象每次都是从主内存中读取，但是自己学习了volatile的可见性及有序性后一直觉得保证的应该是有序性啊！终于找到了两篇文章证实了我的想法！
Java中的volatile关键字详解及单例模式双检锁问题分析
 volatile关键字在单例模式中的应用
这里写图片描述

4.静态内部类单例模式（推荐）

特点：当第一次加载SingleClass类时并不会初始化single，只有在第一次调用SingleClass的getInstance方法时才会导致single被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingleHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式，代码如下：

public class SingleClass {
    private SingleClass(){}
    private static SingleClass getInstance(){
        return SingletonHolder.single;
    }

    private static class SingletonHolder{
        private static final SingleClass single = new SingleClass();
    }
 }

5.枚举单例

特点：写法最简单，并且在任何情况下它都是一个单例。（如反序列化），代码如下：


public enum SingletonEnum{
   INSTANCE;
}

五、Android中关于单例模式引起的内存泄漏

单例模式在Android中使用很可能会造成内存泄漏，如下代码：

  private Context context;
  private static volatile SingleClass single = null;
  private SingleClass(Context context){
       this.context = context;
  }
  public static SingleClass getInstance(Context context){
      if(single==null){
          synchronized (SingleClass.class){
              if(single==null){
                  single = new SingleClass(context);
              }
          }
      }
      return single;
  }

上面是我们最常用的单例模式，但是这个单例却是有内存泄漏的风险。因为如上代码中如果我们在Activity调用该单例，传入Activity实例，这时候我们的单例对象single就持有了Activity的引用，而single是static的，生命周期与应用的生命周期一样，当我们的Activity不需要再使用的时候，正常应该有GC回收，但是由于single一直持有者该Activity的引用，是该Activity得不到回收，很容易造成内存泄漏。解决方法：
1. 可以的话使用全局Application上下文
2. 使用静态变量的弱引用

 private Context context;
 private static volatile SingleClass single = null;
 private static WeakReference<SingleClass> weakReferenceInstance;
 private SingleClass(Context context){
     this.context = context;
 }
 public static SingleClass getInstance(Context context){
     if(single==null){
         synchronized (SingleClass.class){
             if(single==null){
                 if (weakReferenceInstance == null || weakReferenceInstance.get() == null) {
                     weakReferenceInstance = new WeakReference<SingleClass>(new SingleClass(context));
                 }
                 return weakReferenceInstance.get();
             }
         }
     }
     return single;
 }

如有不同意见，请评论探讨，如发现错误，请指正！谢谢