单例模式及其在Android中的应用

单例模式算是设计模式中最简单的模式了，主要是为了保证类只有一个实例，比如保持一个请求队列等。类图也很简单，如下所示：



可以看到，类中有一个类型是本类的私有变量，加上私有的构造方法和公共的getInstance()方法。这样就保证了其它类不能随意的实例化它，必须通过公共的方法才能得到它的实例。

写法有很多种，这里只列出最常用的4种：饿汉、懒汉、DCL(Double Check Lock 双检查锁)和静态内部类。

饿汉

/**
* 饿汉单例模式
*/
public class Singleton {
// 直接实例化自己并赋值给mInstance
private static Singleton mInstance = new Singleton();

// 私有构造方法，保证只有自己才能实例化
private Singleton() {

}

// 外部只有通过此方法得到实例
public static Singleton getInstance() {
return mInstance;
}

}

饿汉模式在定义变量是直接就实例化类了，这样做肯定能保证其它类得到是唯一的。但是这样做有一个坏处，假设这个类从来没被用到，那就浪费了。

懒汉

/**
* 懒汉单例模式
*/
public class Singleton {
// 定义私有的变量，并没有赋值
private static Singleton mInstance;

// 私有构造方法
private Singleton() {

}

// 通过此方法，得到本类的实例化
// 注意synchronized关键字加锁，适用于多线程
public static synchronized Singleton getInstance() {
if (mInstance == null) {
mInstance = new Singleton();
}
return mInstance;
}

}

通过代码，可以看到跟饿汉的最大区别是：饿汉在定义变量时直接赋值，而懒汉比较懒，用到了才临时抱佛脚，去实例化类。

同时注意在getInstance()方法加上了synchronized关键字，如果有两个线程同时访问此方法，而没有加锁的话，就会新建两个实例，那这单例模式就形同虚设了。所以就需要加锁保护，当一个线程访问时，其它线程就阻塞，当访问结束，才释放锁，才其它线程访问。

仔细想想，加上了synchronized的确是保证了线程安全，但是如果mInstance不为空了，我们只需要返回就行。由于加了锁，所有访问都必须等待前一个访问释放，是不是有点不合理？ 看接下来的DCL模式可以避免这个问题。

DCL (Double Check Lock)

public class Singleton {
// 私有变量，注意volatile关键字
private static volatile Singleton mInstance;

// 私有构造方法
private Singleton() {

}
// 公共访问方法，两次判断是否为空
public static Singleton getInstance() {
if (mInstance == null) {
synchronized (Singleton.class) {
if (mInstance == null) {
mInstance = new Singleton();
}
}
}
return mInstance;
}
}

我们重点看getInstance()方法，先判断是否为空，如果不为空，直接返回，这就解决了懒汉模式中提到的不必要的加锁保护。

在往下看synchronized同步代码块，如果为空时才执行此代码块。在这里再次判断mInstanc是否为空，想一想，如果同时有两个线程走到这里，如果没有再次判断是否为空的话，也会实例化两次。双检查锁的两次判空就保证了类只实例化一次

最后，注意一下mInstance变量前多了一个volatile关键字，要想知道此关键字的用意，首先得了解java的内存模型。直接看下图：



简单描述一下，改变一个变量的值，也就是主内存中的值，必须通过3个步骤：assign+store+write操作，读也是需要3个步骤：read+load+use。加上volatile关键字就可以保证按照顺序进行读写，并且每次读取都是从主内存中获取真实值。

静态内部类

DCL在高并发情况下会出现失效问题，如果有高并发的情况，不建议使用，推荐使用静态内部类方式，代码如下：

/**
* 静态内部类单例模式
*/
public class Singleton {
// 私有构造方法
private Singleton() {
}
// 单一全局访问点
public static Singleton getInstance() {
return SingletonHolder.mInstance;
}

// 静态内部类，第一次加载Singleton类时不会初始化mInstance，
// 当调用getInstance()时才会初始化
private static class SingletonHolder {
private static Singleton mInstance = new Singleton();
}
}

可以看到，当调用getInstance()方法时，jvm才会加载SingletonHolder内部类，能确保线程安全，还能够保证对象的唯一性，没有上述3种实现方式的缺点。

Android中的单例模式

Android中用到单例模式的地方还是蛮多的，举两个例子。

Android-Universal-Image-Loader

我们通过网络加载图片的时候一般都会接触此框架，很简单的就可以使用，如下代码：

ImageLoader.getInstance().displayImage(url, imageView);

看看源码，如下：

public class ImageLoader {

// 省略若干代码

private volatile static ImageLoader instance;

/** Returns singleton class instance */
public static ImageLoader getInstance() {
if (instance == null) {
synchronized (ImageLoader.class) {
if (instance == null) {
instance = new ImageLoader();
}
}
}
return instance;
}

protected ImageLoader() {
}

// 省略若干代码

可以看到，源码中使用了DCL的方式去实现的单例模式。

DisplayManagerGlobal

该类主要负责管理显示管理器(Display Manager)与显示管理服务(Display Manager Service)之间的通信。其中也用到了单例模式，代码如下所示：

public final class DisplayManagerGlobal {
// 省略若干代码

private static DisplayManagerGlobal sInstance;

public static DisplayManagerGlobal getInstance() {
synchronized (DisplayManagerGlobal.class) {
if (sInstance == null) {
IBinder b = ServiceManager.getService(Context.DISPLAY_SERVICE);
if (b != null) {
sInstance = new DisplayManagerGlobal(IDisplayManager.Stub.asInterface(b));
}
}
return sInstance;
}
}

}

从代码中可以看到，用到了第二种也就是懒汉模式。