1 单例模式简介

1.1 介绍

单例模式应该是日常使用最为广泛的一种模式了。他的作用是确保某个类只有一个实例，避免产生多个对象消耗过多的资源。比如对数据库的操作时；在一个应用中只有一个ImageLoader实例，这个ImageLoader又含有线程池、缓存系统、网络请求等，很消耗资源，就可以使用单例模式。

1.2 单例模式定义

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

1.3 使用场景

避免某个类产生多个对象而消耗过多的资源，确保某个类在程序中只有一个实例。比如我们使用的图片加载器ImageLoader。往往单例创建的对象，耗费的资源都比较多，所以在初始化单例对象的时候就显得尤为重要了，接下来，我们就来聊一聊单例的几种实现方式。

1.4 使用单例模式需要注意的关键点

（1）将构造函数访问修饰符设置为private （2）通过一个静态方法或者枚举返回单例类对象 （3）确保单例类的对象有且只有一个，特别是在多线程环境下 （4）确保单例类对象在反序列化时不会重新构建对象

2 单例模式UML类图

3 单例模式的六种写法

3.1 饿汉式

/** * 饿汉式实现单例模式 */ public class Singleton { private static Singleton instance = new Singleton(); private Singleton() { } public static Singleton getInstance() { return instance; } }

饿汉式顾名思义，就是这个汉子很饿，一上来就把单例对象创建出来了，要用的时候直接返回即可，这种是单例模式中最简单的一种实现方式。但是问题也比较明显。单例在还没有使用到的时候，初始化就已经完成了。如果程序从头到位都没用使用这个单例的话，单例的对象还是会创建，这就造成了不必要的资源浪费。

3.2 懒汉式

/** * 懒汉式实现单例模式 */ public class Singleton { private static Singleton instance; private Singleton() { } // synchronized方法,多线程情况下保证单例对象唯一 public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }

（1）饿汉式也顾名思义，就是这个汉子比较懒，一开始的时候什么也不做，知道要使用的时候采取创建实例的对象。getInstance()方法中添加了synchronized关键字，使其变成一个同步方法，目的是为了在多线程环境下保证单例对象唯一。 （2）优点： 只有在使用时才会实例化单例，一定程度上节约了资源。 （3）缺点： 第一次加载时要立即实例化，反应稍慢。每次调用getInstance()方法都会进行同步，这样会消耗不必要的资源。这种模式一般不建议使用。

3.3 DCL（Double CheckLock）实现单例（常用）

3.3.1 DCL实现单例模式

** * DCL实现单例模式 */ public class Singleton { private volatile static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { // 两层判空，第一层是为了避免不必要的同步 // 第二层是为了在null的情况下创建实例 if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }

（1）优点： 资源利用率高，既能够在需要的时候才初始化实例，又能保证线程安全，同时调用getInstance()方法不进行同步锁，效率高。 （2）缺点： 第一次加载时稍慢，由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。 因此添加一个volatile关键字，因为在这里会有DCL失效问题，原因是编译器为了提高执行效率的指令重排。只要认为在单线程下是没问题的，它就可以进行乱序写入！以保证不要让cpu指令流水线中断。

3.3.2 JVM的底层机制和执行流程

3.3.3 原因分析

在3.3.1 DCL实现单例模式中的instance = new Singleton();到底发生了什么？

memory = allocate(); //1：分配对象的内存空间 ctorInstance(memory); //2：初始化对象 instance = memory; //3：设置instance指向刚分配的内存地址

上面的伪代码中2、3步重排序之后的执行时序如下：

memory = allocate(); //1：分配对象的内存空间 instance = memory; //3：设置instance指向刚分配的内存地址 //注意，此时对象还没有被初始化！ ctorInstance(memory); //2：初始化对象

为了更好的理解intra-thread semantics（线程内语义），请看下面的示意图（假设一个线程A在构造对象后，立即访问这个对象）。只要保证2排在4的前面，即使2和3之间重排序了，也不会违反intra-thread semantics。 下面，再让我们看看多线程并发执行的时候的情况。如果发生重排序，另一个并发执行的线程B就有可能在第4行判断instance不为null。线程B接下来将访问instance所引用的对象，但此时这个对象可能还没有被A线程初始化！下面是这个场景的具体执行时序： 最后，线程有可能得到一个不为null，但是构造不完全的instance对象（没经过：2.初始化对象步骤）。

3.3.4 解决方法

（1）不允许2和3重排序。在JDK1.5之后，具体化了volatile关键字，只要定义时加上他，可以保证执行的顺序，虽然会影响性能。这种方式第一次加载时会稍慢，在高并发环境会有缺陷，但是一般能够满足需求。 （2）方官方比较推荐的一种方案（effective java 2nd），请看下一节：3.4 静态内部类（推荐）。

3.3.5 参考链接

双重检查锁定与延迟初始化

3.4 静态内部类（推荐）

/** * 静态内部类实现单例模式 */ public class Singleton { private Singleton() { } public static Singleton getInstance() { return SingletonHolder.instance; } /** * 静态内部类 */ private static class SingletonHolder { private static Singleton instance = new Singleton(); } }

因为内部静态类是要在有引用之后才会转载到内存的，所以第一次加载Singleton类时不会初始化instance，只有在第一次调用getInstance()方法时，虚拟机会加载SingletonHolder类初始化instance，保证了单例对象的唯一。 因为getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本，实现了懒加载。因为静态的域只会在虚拟机转载类似初始化一次，并有虚拟机保证线程安全。

3.5 枚举单例

/** * 枚举实现单例模式 */ public enum SingletonEnum { INSTANCE; public void doSomething() { System.out.println("do something"); } }

默认枚举实例的创建是线程安全的，即使反序列化也不会生成新的实例，任何情况下都是一个单例。优点： 简单！

3.6 容器实现单例

/** * 容器类实现单例模式 */ public class SingletonManager { private static Map<String, Object> objMap = new HashMap<String, Object>(); public static void regsiterService(String key, Object instance) { if (!objMap.containsKey(key)) { objMap.put(key, instance); } } public static Object getService(String key) { return objMap.get(key); } }

SingletonManager可以管理多个单例类型，使用时根据key获取对象对应类型的对象。这种方式可以通过统一的接口获取操作，隐藏了具体实现，降低了耦合度。

4 防止单例模式被JAVA反射攻击

（1）举例，通过JAVA的反射机制来“攻击”单例模式

public class ElvisReflectAttack{ public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { Class<?> classType = Singleton.class; Constructor<?> c = classType.getDeclaredConstructor(null); c.setAccessible(true); Elvis e1 = (Singleton)c.newInstance(); Elvis e2 = Singleton.getInstance(); System.out.println(e1==e2); } } // 运行结果：false

小结：通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数，所有e1和e2是两个不同的对象。如果要抵御这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。 （2）以DCL实现单例模式为例

/** * DCL实现单例模式 */ public class Singleton { private volatile static Singleton instance = null; private static boolean flag = false; private Singleton() { synchronized(Singleton.class) { Log.e("Interview_log", "flag:" + flag); if(!flag) { flag = true; } else { //在被要求创建第二个实例的时候抛出异常,无法生成对象实例 throw new RuntimeException("单例模式被侵犯！"); } } } public static Singleton getInstance() { // 两层判空，第一层是为了避免不必要的同步 // 第二层是为了在null的情况下创建实例 if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }

（3）测试demo

private void reflectAttack() { Class<?> classType = Singleton.class; Singleton singleton1 = Singleton.getInstance(); Constructor<?> c = null; try { c = classType.getDeclaredConstructor(); c.setAccessible(true); Singleton singleton2 = null; try { singleton2 = (Singleton) c.newInstance();//反射得到的对象 } catch (Exception e) { Log.e("Interview_log", "Exception：" + e.toString()); e.printStackTrace(); } Log.e("Interview_log", "反射攻击2：" + singleton1.toString()); if (singleton2 == null) { Log.e("Interview_log", "反射攻击3:反射得到的对象为null"); } else { Log.e("Interview_log", "反射攻击3：" + singleton2.toString()); } Log.e("Interview_log", "反射攻击4：" + (singleton1 == singleton2)); } catch (NoSuchMethodException e) { e.printStackTrace(); } }

（3）结果 （4）学习链接 如何防止单例模式被JAVA反射攻击

（5）经过验证，枚举单例可以防止单例模式被“攻击”，也可以防止序列化破坏单例模式。

5 Android源码中的单例模式

在Android系统中，我们经常会通过Context获取系统级别的服务，如WindowsManagerService、ActivityManagerService等，更常用的是一个LayoutInflater的类，这些服务会在合适的时候以单例的形式注册在系统中，在我们需要的时候就通过Context的getSystemService(String name)获取。

6 运用单例模式

7 总结

7.1 优点

（1）由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁的创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。 （2）单例模式可以避免对资源的多重占用，例如一个文件操作，由于只有一个实例存在内存中，避免对同一资源文件的同时操作。 （3）单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

7.2 缺点

（1）单例模式一般没有接口，扩展很困难，若要扩展，只能修改代码来实现。 （2）单例对象如果持有Context，那么很容易引发内存泄露。此时需要注意传递给单例对象的Context最好是Application Context。

8 参考文章与链接

《Android源码设计模式解析与实战》

《设计模式之禅》

单例模式的6种实现方式

单例模式的五种实现方式

DCL失效问题的探讨