单例模式及其在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;
        }
    }


}

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