0. 序言
- 我们要熟练掌握单例模式。不管是实战开发中，还是面试手写设计模式中，都少不了它。
- 通过阅读本篇博文，你会了解常用的单例模式，单例模式三要素，以及如何保证单例模式的安全性。
1. 定义
- 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
2. UML类图
3. 通用代码（饿汉式）
public class Singleton {
private static final Singleton sSingleton = new Singleton();
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static Singleton getSingleton() {
return sSingleton;
}
//类中其他方法，尽量是static
public static void doSometing() {
}
}
4. 三要素（非常重要）
- 私有构造函数。
- 暴露公有静态方法返回单例类唯一对象。
- 在多线程环境下确保单例类对象有且只有一个。
5. 优点
- 只有一个实例，减少内存开支。（频繁创建时）
- 只生成一个实例，减少系统性能开销。（一个对象需要比较多的资源时）
- 避免对资源的多重占用，以免对同一个资源文件同时操作。（比如：写文件时）
- 优化和共享资源访问。（可以在系统设置全局的访问点）
6. 缺点
- 没有接口，扩展困难，只能修改代码。疑问：为什么不增加接口呢？因为单例模式要求“自行实例化”，接口对单例模式没有意义。
- 对测试不利。并行开发环境中，单例模式没有完成，是不能进行测试的。
- 单例模式与单一职责原则有冲突。后者规定一个类应该只实现一个逻辑，是不是单例取决于环境。前者规定必须是单例而且没有规定只能有一个逻辑。
7. 使用场景
- 当要求一个类有且只有一个对象，出现多个对象就会发生“不良反应”时，比如访问I/O或者数据库等资源。
- 整个项目需要一个共享访问点或者共享数据。
- 工具类对象。
8. 注意事项（一）
在高并发的情况下，饿汉式不会出现产生多个实例的情况，但是懒汉式就要注意线程的同步问题，懒汉式代码如下：
public class Singleton {
private static Singleton sSingleton = null;
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static Singleton getSingleton() {
if (sSingleton == null) {
sSingleton = new Singleton();
}
return sSingleton;
}
}
该单例模式在低并发的情况下并不会出现问题，若并发量增大则可能出现多个实例！为什么会这样呢？
如一个线程A执行到sSingleton = new Singleton()，但是没有获得对象（对象初始化是需要时间的），第二个线程B也在执行，执行到（sSingleton == null）判断，那么线程B获得判断条件也是真，于是继续运行下去，线程A获得了一个对象，线程B也获得了一个对象，在内存中就出现两个对象。
解决线程不安全的方法有很多，可以在getSingleton方法前加sychronized关键字，也可以在getSingleton方法内增加sychronized来实现。
public class Singleton {
private static Singleton sSingleton = null;
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static sychronized Singleton getSingleton() {
if (sSingleton == null) {
sSingleton = new Singleton();
}
return sSingleton;
}
}
优点是单例只有在使用时才会被实例化，在一定程序上节约了资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。
所以相比懒汉式，更加推荐饿汉式，当然各有利弊，下文会推荐几种适用的单例模式，别着急，接着往下看。
9. 注意事项（二）
除了担心高并发以外，还需要考虑对象的复制情况。
在Java中，对象默认是不可以被复制的，若实现Cloneable接口，实现clone方法，则可以直接通过对象复制方法创建一个新对象，对象复制是不用调用类的构造函数的，因此即使是私有的构造函数，对象仍然可以被复制。所以解决该问题的方法就是单例类不要实现Cloneable接口。
10. 推荐写法
- 饿汉式模式
public class Singleton {
private static final Singleton sSingleton = new Singleton();
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static Singleton getSingleton() {
return sSingleton;
}
//类中其他方法，尽量是static
public static void doSometing() {
}
}
优点：类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。这种方式基于类加载机制，避免了多线程的同步问题。
缺点：不能达到懒加载的效果，如果从始至终未使用过这个实例，则会造成内存的浪费。
推荐场景：单例模式经常使用的场景下，选择饿汉式。
- 双重检索模式（DCL）
public class Singleton {
private static Singleton sSingleton = null;
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static Singleton getSingleton() {
if (sSingleton == null) {
synchronized (Singleton.class) {
if (sSingleton == null) {
sSingleton = new Singleton();
}
}
}
return sSingleton;
}
}
亮点：在getSingleton方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层判断则是为了在Singleton等于null的情况下才创建实例。
分析：
sSingleton = new Singleton()这句话大致做了3件事情：
①：给Singleton的实例分配内存。
②：调用Singleton()构造函数，初始化成员字段。
③：将sSingleton对象指向分配的内存空间（此时sSingleton不是null了）
但是由于Java编译器允许处理器乱序执行等原因，执行顺序可能是1,2,3，还可能是1,3,2.如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候sSingleton因为已经在线程A内执行过了第三点，sSingleton已经是非空了，所以线程B直接取走sSingleton，再使用时就会出错，导致DCL失效。
为了避免这类事情的发生，JDK1.5之后调整了JVM,具体化了volatile关键字，只需要将sSingleton定义改成private volatile static Singleton sSingleton = null 就可以保证sSingleton对象每次都是从主内存中读取的，保证了可见性和有序性，这样的话就可以使用DCL。以后会有相关Java内存方面的文章，具体阐述volatile关键字。
优点：资源利用率高，第一次执行getSingleton时单例对象才会被实例化。
缺点：第一次加载时反应稍慢。
推荐理由：资源利用率高！线程安全！绝大多数场景下可以保证单例对象的唯一性。
完整代码：
public class Singleton {
private volatile static Singleton sSingleton = null;
//限制产生多个对象
private Singleton() {
}
//通过该方法获得实例对象
public static Singleton getSingleton() {
if (sSingleton == null) {
synchronized (Singleton.class) {
if (sSingleton == null) {
sSingleton = new Singleton();
}
}
}
return sSingleton;
}
}
- 静态内部类单例模式（最推荐的）
DCL虽然解决了资源消耗、多余的同步、线程安全等问题，但是在高并发场景比较复杂的情况下依然会出现失效的问题，所以推荐使用静态内部类单例模式：
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方法时才会导致sInstance被初始化。 - 线程安全和单例对象唯一性：
第一次调用Singleton的getInstance方法时会导致虚拟机加载SingletonHolder类，这种方式确保了线程安全，还保证了单例对象的唯一性。
推荐理由:懒加载、线程安全、单例对象唯一性。
- 枚举模式
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("do sth.");
}
private Object readResolve() throws ObjectStreamException {
return INSTANCE;
}
}
优点：默认枚举实例的创建实线程安全的，并且在任何情况下它都是一个单例，包括序列化。
推荐理由：写法简单，甚至在反序列化的情况下，依然可以保证单例的唯一性。
- 容器模式
public class Singleton {
private static Map<String, Object> objMap = new HashMap<String, Object>();
private Singleton() {
}
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获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
11. 特别注意
通过反序列化，上面几种单例模式都会出现
重新创建对象的情况，枚举不包括在内。
通过反序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而获得一个实例。及时构造函数是私有的，反序列化依然可以通过特殊途径去创建类的一个新的实例。
反序列化操作提供了一个很特别的函数，类中具有一个私有的、被实例化的方法readResolve，通过这个方法可以让开发人员控制对象的反序列化。
所以上述几个示例（不包括枚举）中如果要杜绝单例对象在被反序列化时重新生成对象，必须加入以下方法
private Object readResolve() throws ObjectStreamException {
return sInstance;
}
readResolve方法将sInstance对象返回，而不是默认的重新生成一个新的对象。
12. 后续
如果大家喜欢这篇文章，欢迎点赞；如果想看更多 设计模式 方面的技术，欢迎关注！
