一 单例模式介绍及它的使用场景
单例模式是应用最广的模式，也是我最先知道的一种设计模式，在深入了解单例模式之前，每当遇到如：getInstance（）这样的创建实例的代码时，我都会把它当做一种单例模式的实现。其实经常使用的图片加载框架ImageLoader的实例创建就是使用了单例模式，因为这个ImageLoader中含有线程池、缓存系统、网络请求，很消耗资源，不应该创建多个对象，这时候就需要用到单例模式。
ImageLoader的创建代码如下：
ImageLoader.getInstance();// 在自己的Application中创建全局实例
//getInstance()执行的源码
public static ImageLoader getInstance() {
if(instance == null) {//双重校验DCL单例模式
Class var0 = ImageLoader.class;
synchronized(ImageLoader.class) {//同步代码块
if(instance == null) {
instance = new ImageLoader();//创建一个新的实例
}
}
}
return instance;//返回一个实例
}
因此，在我们创建一个对象需要消耗过多的资源时，便可以考虑使用单例模式。
二 单例模式的结构图以及创建的关键点？
单例模式的定义是它应该保证一个类仅有一个实例，同时这个类还必须提供一个访问该类的全局访问点。如下图是单例模式的结构图：
实现单例模式有以下几个关键点：
（1）其构造函数不对外开放，一般为private；
（2）通过一个静态方法或者枚举返回单例类对象；
（3）确保单例类的对象有且只有一个，尤其要注意多线程的场景；
（4）确保单例类对象在反序列化时不会重新创建对象；
通过将单例类的构造函数私有化，使得客户端不能通过new的形式手动构造单例类的对象。单例类会主动暴露一个公有的静态方法，客户端调用这个静态的方法获取到单例类的唯一实例。在获取这个单例类的时候需要确保这个过程是线程安全的。
三 单例模式的七种实现方式
（1）懒汉式（线程不安全）
//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton {
//私有的构造函数
private Singleton() {}
//私有的静态变量
private static Singleton single=null;
//暴露的公有静态方法
public static Singleton getInstance() {
if (single == null) {
single = new Singleton();
}
return single;
}
}
懒汉式（线程不安全）的单例模式分为三个部分：私有的构造方法，私有的全局静态变量，公有的静态方法。
其中起到重要作用的是静态修饰符static关键字，我们知道在程序中，任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，因此也就保证了单例类的实例一旦创建，便不会被系统回收，除非手动设置为null。
缺点：是存在线程不安全的问题，解决的办法就是使用synchronized 关键字，便是单例模式的第二种写法了。
（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 关键字，也就是告诉Java（JVM）getInstance是一个同步方法。
同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时， 一个时间内只能有一个线程得到执行，另一个线程必须等待当前线程执行完才能执行，因此同步方法使得线程安全，保证了单例只有唯一个实例。
缺点：getInstance方法是用synchronized修饰的，该方法是同步的，为了保证线程安全，但是导致每次调用该方法的时候都会被同步，这样会消耗不必要的资源（不必要的同步开销）。所以这种模式一般不建议使用。
（3）饿汉模式（线程安全）
代码实现如下：
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton {
//static修饰的静态变量在内存中一旦创建，便永久存在
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。其中instance=new Singleton()可以写成：
static {
instance = new Singleton();
}
属于变种的饿汉单例模式，也是基于classloder机制避免了多线程的同步问题。
缺点：实例对象是static的，在声明的时候就实例化了，浪费资源。
（4）DCL双重校验模式
public class Singleton {
private static Singleton singleton; //静态变量
private Singleton (){} //私有构造函数
public static Singleton getInstance() {
if (singleton == null) { //第一层校验
synchronized (Singleton.class) {
if (singleton == null) { //第二层校验
singleton = new Singleton();
}
}
}
return singleton;
}
}
这种模式的亮点在于getInstance（）方法上，其中对singleton 进行了两次判断是否空，第一层判断是为了避免不必要的同步，第二层的判断是为了在null的情况下才创建实例，避免了每次都同步造成的不必要的资源消耗。
但这种写法并不是一定没有问题的，在高并发情况下，会偶尔失效。
具体我们来分析一下：
假设线程A执行到了singleton = new Singleton(); 语句，这里看起来是一句代码，但是它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致会做三件事情：
（a）给Singleton的实例分配内存
（b）调用Singleton（）的构造函数，初始化成员字段；
（c）将singleton对象指向分配的内存空间（即singleton不为空了）；
但是由于Java编译器允许处理器乱序执行，以及在jdk1.5之前，JMM（Java Memory Model：java内存模型）中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序可能是a-b-c，也可能是a-c-b,如果是后者的指向顺序，并且恰恰在c执行完毕，b尚未执行时（这里不讨论a和b或b和c等有关联的情况），被切换到线程B中，这时候因为singleton在线程A中执行了步骤c了，已经非空了，所以，线程B直接就取走了singleton，再使用时就会出错。这就是DCL失效问题。
但是在JDK1.5之后，官方给出了volatile关键字，将singleton定义的代码改成：
private volatile static Singleton singleton;
//使用volatile 关键字 两种特性：变量可见性、禁止重排序
//一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程
这样就解决了DCL失效的问题。推荐方式
（5）静态内部类单例模式
public class Singleton {
private Singleton (){} ;//私有的构造函数
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
//定义的静态内部类
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton(); //创建实例的地方
}
}
当第一次加载Singleton 类的时候并不会初始化INSTANCE ，只有第一次调用Singleton 的getInstance（）方法时才会导致INSTANCE 被初始化。因此，第一次调用getInstance（）方法会导致虚拟机加载SingletonHolder 类，这种方式不仅能够确保单例对象的唯一性，同时也延迟了单例的实例化。推荐方式
（6）枚举单例
前面的几种单例模式实现方式，一般都会稍显麻烦，或是在某些特定的情况下出现一些状况。下面介绍枚举单例模式的实现：
public enum Singleton { //enum枚举类
INSTANCE;
public void whateverMethod() {
}
}
枚举单例模式最大的优点就是写法简单，枚举在java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例是线程安全的，并且在任何情况下，它都是一个单例。即使是在反序列化的过程，枚举单例也不会重新生成新的实例。而其他几种方式，必须加入如下方法：
private Object readResolve() throws ObjectStreamException{
return INSTANCE;
}
才能保证反序列化时不会生成新的对象。
（7）使用容器实现单例模式
除了上述几种常见的实现单例的方式，还有另一类的实现，代码如下：
public class SingletonManager {
private static Map<String, Object> objMap = new HashMap<String,Object>();//使用HashMap作为缓存容器
private Singleton() {
}
public static void registerService(String key, Objectinstance) {
if (!objMap.containsKey(key) ) {
objMap.put(key, instance) ;//第一次是存入Map
}
}
public static ObjectgetService(String key) {
return objMap.get(key) ;//返回与key相对应的对象
}
}
在程序的初始，将多种单例模式注入到一个统一的管理类中，在使用时根据key获取对应类型的对象。
在Android源码中，APP启动的时候，虚拟机第一次加载该类时会注册各种ServiceFetcher，比如LayoutInflater Service。将这些服务以键值对的形式存储在一个HashMap中，用户使用时只需要根据key来获取到对应的ServiceFetcher，然后通过ServiceFetcher对象的getService函数获取具体的服务对象。当第一次获取时，会调用ServiceFetcher的creatService函数创建服务对象，然后将该对象缓存到一个列表中，下次再取时直接从缓存中获取，避免重复创建对象，从而达到单例的效果。Android中的系统核心服务以单例形式存在，减少了资源消耗。
总结：一般情况下（4）DCL双重校验模式（5）静态内部类单例模式 方式够用特殊情况下的使用根据具体情况再做修改。不管以哪种形式实现单例模式，它们的核心原理是将构造函数私有化，并且通过静态公有方法获取一个唯一的实例，在这个获取的过程中必须保证线程的安全，同时也要防止反序列化导致重新生成实例对象。
解析稍作修改
原文链接：https://blog.csdn.net/happy_horse/article/details/51164262
