Android设计模式之单例模式的七种写法

一 单例模式介绍及它的使用场景

单例模式是应用最广的模式，也是我最先知道的一种设计模式。在深入了解单例模式之前。每当遇到如：getInstance（）这样的创建实例的代码时，我都会把它当做一种单例模式的实现。

事实上常常使用的图片载入框架ImageLoader的实例创建就是使用了单例模式。由于这个ImageLoader中含有线程池、缓存系统、网络请求，非常消耗资源，不应该创建多个对象，这时候就须要用到单例模式。

ImageLoader的创建代码例如以下：

ImageLoader.getInstance();// 在自己的Application中创建全局实例
.....
//getInstance()运行的源代码
 public static ImageLoader getInstance() {
        if(instance == null) {//双重校验DCL单例模式
            Class var0 = ImageLoader.class;
            synchronized(ImageLoader.class) {//同步代码块
                if(instance == null) {
                    instance = new ImageLoader();//创建一个新的实例
                }
            }
        }
        return instance;//返回一个实例
    }

因此，在我们创建一个对象须要消耗过多的资源时。便可以考虑使用单例模式。

二 单例模式的结构图以及创建的关键点？

单例模式的定义是它应该保证一个类仅有一个实例，同一时候这个类还必须提供一个訪问该类的全局訪问点。例如以下图是单例模式的结构图：

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

（1）其构造函数不正确外开放，一般为private；

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

（3）确保单例类的对象有且仅仅有一个，尤其要注意多线程的场景。

（4）确保单例类对象在反序列化时不会又一次创建对象；

通过将单例类的构造函数私有化，使得client不能通过new的形式手动构造单例类的对象。单例类会主动暴露一个公有的静态方法。client调用这个静态的方法获取到单例类的唯一实例。在获取这个单例类的时候须要确保这个过程是线程安全的。

三 单例模式的七种实现方式

（1）懒汉式（线程不安全）

//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton {
    //私有的构造函数
    private Singleton() {}
    //私有的静态变量
    private static Singleton single=null;
    //暴露的公有静态方法
    public static Singleton getInstance() {
         if (single == null) {
             single = new Singleton();
         }
        return single;
    }
}

懒汉式（线程不安全）的单例模式分为三个部分：私有的构造方法，私有的全局静态变量。公有的静态方法。

当中起到重要作用的是静态修饰符static关键字，我们知道在程序中，不论什么变量或者代码都是在编译时由系统自己主动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在。直到程序退出内存才会释放这个空间。因此也就保证了单例类的实例一旦创建，便不会被系统回收，除非手动设置为null。

这样的方式创建的缺点是存在线程不安全的问题，解决的办法就是使用synchronized 关键字，便是单例模式的另外一种写法了。

（2）懒汉式（线程安全）

public class Singleton {
    //私有的静态变量
    private static Singleton instance;
    //私有的构造方法
    private Singleton (){}；
    //公有的同步静态方法
    public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
    }
}  

这样的单例实现方式的getInstance（）方法中加入了synchronized 关键字，也就是告诉Java（JVM）getInstance是一个同步方法。

同步的意思是当两个并发线程訪问同一个类中的这个synchronized同步方法时， 一个时间内仅仅能有一个线程得到运行，还有一个线程必须等待当前线程运行完才干运行，因此同步方法使得线程安全，保证了单例仅仅有唯一个实例。

可是它的缺点在于每次调用getInstance（）都进行同步，造成了不必要的同步开销。这样的模式一般不建议使用。

（3）饿汉模式（线程安全）

代码实现例如以下：

//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton {
    //static修饰的静态变量在内存中一旦创建，便永久存在
    private static Singleton instance = new Singleton();
    private Singleton (){}
    public static Singleton getInstance() {
    return instance;
    }
} 

饿汉式在类创建的同一时候就已经创建好一个静态的对象供系统使用。以后不再改变，所以天生是线程安全的。当中instance=new Singleton()可以写成：

 static {
    instance = new Singleton();
    }  

属于变种的饿汉单例模式，也是基于classloder机制避免了多线程的同步问题，instance在类装载时就实例化了。

（4）DCL双重校验模式

public class Singleton {
    private static Singleton singleton;  //静态变量
    private Singleton (){}  //私有构造函数
    public static Singleton getInstance() {
      if (singleton == null) {  //第一层校验
          synchronized (Singleton.class) {
          if (singleton == null) {  //第二层校验
              singleton = new Singleton();
          }
        }
      }
    return singleton;
    }
}  

这样的模式的亮点在于getInstance（）方法上，当中对singleton 进行了两次推断是否空，第一层推断是为了避免不必要的同步。第二层的推断是为了在null的情况下才创建实例。详细我们来分析一下：

如果线程A运行到了singleton = new Singleton(); 语句，这里看起来是一句代码，可是它并非一个原子操作，这句代码终于会被编译成多条汇编指令，它大致会做三件事情：

（a）给Singleton的实例分配内存

（b）调用Singleton（）的构造函数，初始化成员字段。

（c）将singleton对象指向分配的内存空间（即singleton不为空了）；

可是由于Java编译器同意处理器乱序运行。以及在jdk1.5之前，JMM（Java Memory Model：java内存模型）中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的运行顺序是不保证了。也就是说运行顺序可能是a-b-c。也可能是a-c-b,如果是后者的指向顺序，而且恰恰在c运行完成。b尚未运行时，被切换到线程B中。这时候由于singleton在线程A中运行了步骤c了，已经非空了。所以。线程B直接就取走了singleton，再使用时就会出错。

这就是DCL失效问题。

可是在JDK1.5之后，官方给出了volatile关键字，将singleton定义的代码改成：

private volatile static Singleton singleton;  //使用volatile 关键字

这样就攻克了DCL失效的问题。

（5）静态内部类单例模式

public class Singleton {
    private Singleton (){} ;//私有的构造函数
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    //定义的静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();  //创建实例的地方
    }
}  

当第一次载入Singleton 类的时候并不会初始化INSTANCE ，仅仅有第一次调用Singleton 的getInstance（）方法时才会导致INSTANCE 被初始化。因此，第一次调用getInstance（）方法会导致虚拟机载入SingletonHolder 类，这样的方式不仅可以确保单例对象的唯一性，同一时候也延迟了单例的实例化。

（6）枚举单例

前面的几种单例模式实现方式，一般都会稍显麻烦，或是在某些特定的情况下出现一些状况。以下介绍枚举单例模式的实现：

public enum Singleton {  //enum枚举类
    INSTANCE;
    public void whateverMethod() {  

    }
}

枚举单例模式最大的长处就是写法简单，枚举在java中与普通的类是一样的。不仅可以有字段，还可以有自己的方法，最重要的是默认枚举实例是线程安全的，而且在不论什么情况下。它都是一个单例。即使是在反序列化的过程。枚举单例也不会又一次生成新的实例。而其它几种方式。必须加入例如以下方法：

private Object readResolve()  throws ObjectStreamException{
    return INSTANCE;
}

才干保证反序列化时不会生成新的对象。

（7）使用容器实现单例模式

除了上述几种常见的实现单例的方式，还有还有一类的实现，代码例如以下：

public class SingletonManager {
　　private static Map<String, Object> objMap = new HashMap<String,Object>();//使用HashMap作为缓存容器
　　private Singleton() {
　　}
　　public static void registerService(String key, Objectinstance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;//第一次是存入Map
　　　　}
　　}
　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;//返回与key相相应的对象
　　}
}

在程序的初始。将多种单例模式注入到一个统一的管理类中，在使用时依据key获取相应类型的对象。

在Android源代码中。APP启动的时候。虚拟机第一次载入该类时会注冊各种ServiceFetcher，比方LayoutInflater Service。将这些服务以键值对的形式存储在一个HashMap中。用户使用时仅仅须要依据key来获取到相应的ServiceFetcher。然后通过ServiceFetcher对象的getService函数获取详细的服务对象。当第一次获取时。会调用ServiceFetcher的creatService函数创建服务对象。然后将该对象缓存到一个列表中。下次再取时直接从缓存中获取，避免反复创建对象，从而达到单例的效果。Android中的系统核心服务以单例形式存在，降低了资源消耗。

总结：无论以哪种形式实现单例模式。它们的核心原理是将构造函数私有化，而且通过静态公有方法获取一个唯一的实例。在这个获取的过程中必须保证线程的安全。同一时候也要防止反序列化导致又一次生成实例对象。