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

介绍

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

单例模式的定义

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

单例模式的使用场景

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

单例模式 UML 类图

UML 类图如图所示：

角色介绍：

1. Client - 高层客户端
2. Singleton - 单例类

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

1. 构造函数不对外开放，一般为private；
2. 通过一个静态方法或者枚举返回单例类对象；
3. 确保单例类的对象有且只有一个，尤其是在多线程环境下；
4. 确保单例类对象在反序列化时不会重新构建对象。

通过将单例类的构造函数私有化，使得客户端代码不能通过new的形式手动构造单例类的对象。单例类会暴露一个公有静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例对象的过程中需要确保线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

单例模式的简单示例(饿汉模式)

单例模式是设计模式中比较简单的，只有一个单例类，没有其他的层级结构与抽象。该模式需要确保该类只能生成一个对象，通常是该类需要消耗较多的资源或者没有多个实例的情况。例如，一个公司只有一个CEO、一个应用只有一个Application对象等。下面以公司里的CEO为例来简单演示一下，一个公司可以有几个VP、无数个员工，但是CEO只有一个，请看下面示例。

//普通员工
public class Staff() {
    public void work() {
        //干活
    }
}

//副总裁
public class VP extends Staff {
    @Override
    public void work() {
        //管理下面的经历
    }
}

//CEO,饿汉单例模式
public class CEO extends Staff {
    private static final CEO mCeo = new CEO();
    //构造函数私有
    private CEO() {
    }

    //公有的静态函数，对外暴露获取单例对象的接口
    public static CEO getCeo() {
        return mCeo;
    }

    @Override
    public void work() {
        //管理VP
    }
}

//公司类
public class Company {
    private List<Staff> allStaffs = new ArrayList<Staff>();
    public void addStaff(Staff per) {
        allStaffs.add(per);
    }

    public void showAllStaffs() {
        for (Staff per : allStaffs) {
            System.out.println("Obj :" + per.toString());
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Company cp = new Company();

        // CEO对象只能通过 getCeo函数获取
        Staff ceo1 = CEO.getCeo();
        Staff ceo2 = CEO.getCeo();
        cp.addStaff(ceo1);
        cp.addStaff(ceo2);
        
        //通过 new 创建 VP 对象
        Staff vp1 = new VP();
        Staff vp2 = new VP();
        cp.addStaff(vp1);
        cp.addStaff(vp2);

        //通过 new 创建 Staff 对象
        Staff staff1 = new Staff();
        Staff staff2 = new Staff();
        Staff staff3 = new Staff();
        cp.addStaff(staff1);
        cp.addStaff(staff2);
        cp.addStaff(staff3);

        cp.showAllStaffs();
    }
}

输出结果如下：

Obj : com.example.test.company.CEO@5e8fce95
Obj : com.example.test.company.CEO@5e8fce95
Obj : com.example.test.company.VP@3343c8b3
Obj : com.example.test.company.VP@222d2a10
Obj : com.example.test.company.Staff@1aa8c488
Obj : com.example.test.company.Staff@3dfeca64
Obj : com.example.test.company.Staff@2299b08

从上述的代码中可以看到，CEO类不能通过 new 的形式构造对象，只能通过 CEO.getCeo()函数来获取，而这个CEO对象是静态对象，并且在声明的时候就已经初始化，这就保证了CEO对向的唯一性。从输出结果中发现，两次输出的CEO对象都是一样的，而VP、Staff等类型的对象都是不同的。这个实现的核心在于将CEO类的构造方法私有化，是的外部程序不能通过构造函数来构造CEO对象，而CEO类通过一个静态方法返回一个静态对象。

单例模式的其他实现方式

懒汉模式

懒汉模式是声明一个静态对象，并且在用户第一次调用getInstance时进行初始化，而上述的饿汉模式(CEO类) 是在声明静态对象时就已经初始化。懒汉单例模式实现如下：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton()；
        }
        return instance;
    }
}

你可能已经发现了，getInstance()方法中添加了 synchronized 关键字，也就是getInstance()是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。细想一下，大家可能会发现一个问题，即使 instance 已经被初始化(第一次调用时就会被初始化 instance)，每次调用 getInstance() 方法都会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大问题。

最后总结一下，懒汉单例模式的优点是单例只有在使用时才会被初始化，在一定成都上节约了资源；缺点是第一次加载时需要及时进行初始化，反应稍慢，最大的问题是每次调用getInstance()都进行同步，造成不必要的同步开销。这种模式一般不建议使用。

Double Check Lock(DCL)实现单例

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

public class Singleton {
    private static Singleton instance = null;
    private Singleton() { }

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

这段代码的亮点自然都在getInstance()方法上，可以看到getInstance()方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层判断则是为了在null的情况下创建实例。这是什么意思呢？是不是有点摸不着头脑，下面就一起来分析一下。

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

1. 给 Singleton 的实例分配内存；
2. 调用Singleton()的构造函数，初始化成员字段；
3. 将instance 对象指向分配的内存空间(此时instance就不是null)。

但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM(Java Memory Model，即Java内存模型)中Cache、寄存器到主内存回写顺序的规定，上面的第二和第三的顺序是无法保证的。也就是说，执行顺序可能是1-2-3也可能是1-3-2。如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候instance因为已经在线程A内执行过了第三点，instance已经是非空了，所以，线程B直接取走instance，再使用时就会出错，这就是DCL失效问题，而且这种难以跟踪难以重现的错误很可能会隐藏很久。

在JDK1.5之后，SUN官方已经注意到这种问题，调整了JVM，具体化了volatile关键字，因此，如果JDK是1.5或之后的版本，只需要将instance的定义改成private volatile static Singleton instance = null就可以保证instance对象每次都是从主内存中读取，就可以使用DCL的写法来完成单例。当然，volatile 或多或少也会影响到性能，但考虑到程序的正确性，牺牲这点性能还是值得的。

DCL的优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。缺点：第一次加载时反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然能够在绝大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK6版本下使用，否则，这种方式一般能满足需求。

静态内部类单例模式(推荐)

DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但是，它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定(DCL)失效，在《Java 并发编程实践》一书的最后谈到了这个问题，并指出这种“优化”是丑陋的，不赞成使用。而建议使用如下的代码替代：

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方法时才会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。

枚举单例

前面讲解了一些单例模式实现方式，但是，这些实现方式不是稍显麻烦就是会在某些情况下出现问题。还有没有更简单的实现方式呢？我们看看下面的实现：

public enum SingletonEnum {
    INSTANCE;
    public void method() {
        System.out.println("do sth.");
    }
}

什么？枚举！没错，就是枚举！

写法简单是枚举单例最大的优点，枚举在Java中与普通的类是一样的，不仅能够有字段，还能够有自己的写法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

为什么这么说呢？在上述的几种单例模式实现中，在一个情况下它们会出现重新创建对象的情况，那就是反序列化。

通过序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而有效地获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。反序列化操作提供类一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。例如，上述几个示例中如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入如下方法：

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

也就是在readResolve方法中将sInstance对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。

使用容器实现单例模式

在学习了上述各类单例模式的实现之后，再来看看一种另类的实现，具体代码如下：

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<String, Object>();

    private SingletonManager() { }

    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objMap.get(key);
    }
}

在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

不管以哪种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。选择哪种实现方式取决于项目本身，如是否是复杂的并发环境、JDK版本是否过低、单例对象的资源消耗等。

运用单例模式

在Android应用开发过程中，ImageLoader是我们最为常用的开发工具库之一。Android中最著名的ImageLoader就是 Universal-Image-Loader ,它的使用过程大概是这样的：

public void initImageLoader(Context context) {
    //1. 使用Builder构建ImageLoader的配置对象
    ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
        //加载图片的线程数
        .threadPriority(Thread.NORM_PRIORITY - 2)
        //解码图像的大尺寸，将在内存中缓存先前解码图像的小尺寸
        .denyCacheImageMultipleSizesInMemory()
        //设置磁盘缓存文件名称
        .discCacheFileNameGenerator(new Md5FileNameGenerator())
        //设置加载显示图片队列进程
        .tasksProcessingOrder(QueueProcessingType.LIFO)
        .writeDebugLogs()
        .build();
    //2. 使用配置对象初始化 ImageLoader
    ImageLoader.getInstance().init(config);
    //3. 加载图片
    ImageLoader.getInstance().displayImage("图片 url", imageView);
}

代码中出现了熟悉的getInstance()方法，因此，我们猜测这个ImageLoader使用的是单例模式。正好，之前博客的《面向对象 - 六大原则》中ImageLoader也是类似的实现，通过一个getInstance函数返回单例对象，具体代码如下：

public final class ImageLoader {
    //ImageLoader 实例
    private static ImageLoader sInstance;
    //网络请求队列
    private RequestQueue mImageQueue;
    //缓存
    private volatile BitmapCache mCache = new MemoryCache();
    //图片加载配置对象
    private ImageLoaderConfig mConfig;
    //私有构造函数
    private ImageLoader() {
    }

    /**
     * 获取 ImageLoader单例，DCL形式
     * @return 单例对象
     */
    public static ImageLoader getInstance() {
        if (sInstance == null) {
            synchronized (ImageLoader.class) {
                if (sInstance == null) {
                    sInstance = new ImageLoader();
                }
            }
        }
        return sInstance;
    }

    /**
     * 通过配置类初始化ImageLoader，设置线程数量、缓存策略、加载策略等
     * @param config配置对象
     */
    public void init(ImageLoaderConfig config) {
        mConfig = config;
        mCache = mConfig.bitmapCache;
        checkConfig();
        mImageQueue = new RequestQueue(mConfig.threadCount);
        mImageQueue.start();
    }
    //代码省略

    //加载图片的接口
    public void displayImage(ImageView imageView, String url) {
        displayImage(imageView, url, null, null);
    }

    public void displayImage(ImageView imageView, String uri, ImageListener listener) {
        displayImage(imageView, uri, null, listener);
    }

    public void displayImage(final ImageView imageView, final String uri, final DisplayConfig 
                            config, final ImageListener listener) {
            BitmapRequest request = new BitmapRequest(imageView, uri, config, listener);
            //加载的配置对象，如果没有设置，则使用ImageLoader的配置
            request.displayConfig = request.displayConfig !=null ? request.displayConfig : mConfig.displayConfig;
            //添加到队列中
            mImageQueue.addRequest(request);
        }
    }

    public void stop() {
        mImageQueue.stop();
    }

    //图片加载Listener, 加载完成后毁掉客户端代码
    public static interface ImageListener {
        public void onComplete(ImageView imageView, Bitmap bitmap, String uri);
    }
}

我们的ImageLoader类中将构造函数私有化，并且使用Double Check Lock的形式实现单例，用户通过getInstance 方法获取ImageLoader 单例对象。在用户使用之前需要使用ImageLoaderConfig来配置ImageLoader，配置合理的情况下才会启动用户指定数量的线程来执行图片加载请求。当用户调用display方法是，ImageLoader会将请求构造成一个BitmapRequest，然后将该请求添加到请求队列中，图片加载线程（RequestDispatcher）会从请求队列（RequestQueue）中获取图片加载请求，然后加载该图片，并且将图片显示到对应的ImageView上，最后将图片缓存到缓存系统中。

在后续章节中将会阐述关于该ImageLoader 的更多细节，大家可以到这个 GitHub 下载该库的源代码，并且结合《教你写Android ImageLoader框架》系列博文进行学习。

总结

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

优点

1. 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
2. 由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式解决。
3. 单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时操作。
4. 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

缺点

1. 单例模式一般没有接口，扩展很苦难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
2. 单例对象如果持有Context，那么很容易就引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context。

本文转载自《Android源码设计模式解析与实战》一书，手敲一遍，加深印象。原作者在这