单例模式是应用最广的设计模式之一，就算是你没有听说过设计模式，但也一定听说过单例，这个模式也可能是很多初级程序员唯一会使用的涉及模式。在这个模式中，单例对象的类必须保证只有一个实例存在。即不能自由构造对象的情况，就是单例模式的使用场景。
设计模式的使用场景很常见，一般如果碰到如下情况时，就应该考虑使用单例：
确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就应该考虑使用单例模式。
单例模式的实现不难，只要做到了如下几点，那么就是一个单例模式：
- 构造函数不对外开放，一般为private；
- 通过一个静态方法或者枚举返回单例类对象；
- 确保单例类的对象有且仅有一个，尤其是在多线程的环境下；
- 确保单例类对象在反序列化时不会重新构建对象；
单例模式有很多种写法，下面由浅入深列出常见的7种方式：
1. 饿汉模式：
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
饿汉式单例是最简单的单例了，但在声明静态变量时就已经初试化了。于是问题就来了，如果我没有使用到这个单例，那这个初始化岂不是浪费空间？于是就有了如下懒汉式的写法：
2. 懒汉式单例：
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()时都会进行同步，造成不必要的同步开销。所以这种模式不建议采用。
3. Double Check Lock 式单例
public class Singleton {
private static Singleton instance ;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
这种模式的资源利用率高，第一次执行getInstance()时单例对象才会被实例化，效率高。缺点是第一次加载反应慢，也由于Java内存模型的原因偶尔会失败，在高并发下也有一定的缺陷，虽然发生的概率较小。
关于这种写法，强烈建议看一下这篇文章：Java 单例真的写对了么?。这篇文章里分析了这种单例模式的问题所在，而且使用了volatile关键字给出了优化版本的双重检查机制，也是本文种第七个单例实现方案。
4. 静态内部类式单例，推荐
public class Singleton {
private Singleton() {}
public static synchronized Singleton getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder {
private static final Singleton instance = new Singleton();
}
}
首先强烈推荐这种实现方式。当第一次加载Singleton类时并不会初始化instance，只有在第一次调用Singleton的getInstance方法时才会导致instance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这时推荐使用的单例模式的实现方式。
5. 枚举单例
public enum Singleton {
SINGLETON;
public void doSomethingd() {
System.out.print("do sth.");
}
}
这种方案可能是单例的最简单写法了，枚举在Java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。例如反序列化情况，当从磁盘序列化到内存时，即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个信的实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。后面会说到。
也就是说，前面的几个单例并没有避免序列化时创建新的对象，而枚举则不存在这个问题
6. 容器单例模式
public class SingletonManager {
private static Map<String, Object> objectMap = new HashMap<>();
private SingletonManager() {}
public static void registerService(String key, Object obj) {
if(!objectMap.containsKey(key)) {
objectMap.put(key, obj);
}
}
public static Object getService(String key) {
return objectMap.get(key);
}
}
这种方式很另类，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对应的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。在Android中这种方式就类似与Context.getSystemService(String)。
7. 线程安全的饿汉式单例，推荐：
public class Singleton {
private static volatile Singleton instance = null;
private Singleton() {}
public static Singleton getInstance () {
Singleton inst = instance; // <<< 在这里创建临时变量
if (inst == null) {
synchronized (Singleton.class) {
inst = instance;
if (inst == null) {
inst = new Singleton();
instance = inst;
}
}
}
return inst; // <<< 注意这里返回的是临时变量
}
}
本方法就是上文提到了对双重检查锁定的升级版本。具体信息请看参考文章。
序列化问题：
传统单例写法，如果实现了序列化接口，他们就不能再保持单例，因为readObject() 方法每次会返回新的对象，所以你需要重写这个方法：
private Object readResolve(){
return INSTANCE;
}
