单例模式

单例模式是为了确保某个实例只会被初始化一次，确保我们每次使用到的对象都是同一个，这样能够大大节约应用占用的内存。

单例写法

单例模式的写法很多，还分懒汉式跟饿汉式，区别就在于一个是需要时才实例化一个是类被加载时就完成实例化。我们来看一下合理的且常见的几种懒汉单例写法

DCL（Double Check Lock，双重检查锁）

public class Singleton {

    private static Singleton sSingleton;

    private Singleton(){}

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

}

DCL双重检查锁。内层检查是为了支持线程并发，保证在并发情况下单例的保持，外层检查是为了在处理同步问题后进一步提升代码效率。这种写法问题在于代码重拍导致判断失误。

代码重拍问题

首先，new Singleton()不是一个原子操作，它可以分为：分配内存空间、初始化对象、将对象指向分配的内存空间。而且只有在将对象指向分配的内存控件后sSingleton != null才成立。在编译器编译时为了优化单线程中的执行性能是可以将2，3两步进行重排。重拍后就变成：分配内存空间、将对象指向分配的内存空间、初始化对象。这样的话在多线程情况下是有可能产生一种情况：某个线程获取到的sSingleton对象是分配了地址，但是却没有完成实例化的。所以，我们来看下一种方式。

DCL + volatile

public class Singleton {

    private volatile static Singleton sSingleton;

    private Singleton(){}

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

}

为单例成员变量增加了 volatile关键字。volatile关键字的作用主要是：保持内存可见性与防止指令重排序。很显然我们是利用它避免new Singleton()操作的指令重排。

volatile原理浅析

保存内存可见性
Java是通过几种原子操作完成工作内存和主内存的交互：
lock：作用于主内存，把变量标识为线程独占状态。
unlock：作用于主内存，解除独占状态。
read：作用主内存，把一个变量的值从主内存传输到线程的工作内存。
load：作用于工作内存，把read操作传过来的变量值放入工作内存的变量副本中。
use：作用工作内存，把工作内存当中的一个变量值传给执行引擎。
assign：作用工作内存，把一个从执行引擎接收到的值赋值给工作内存的变量。
store：作用于工作内存的变量，把工作内存的一个变量的值传送到主内存中。
write：作用于主内存的变量，把store操作传来的变量的值放入主内存的变量中。

被volatile修饰的变量
read、load、use动作必须连续出现
assign、store、write动作必须连续出现
因此就能够保证变量的值对于不同线程是实时可见的

防止进行指令重排
编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。插入内存屏障相当于告诉CPU跟编译器，先于这个命令的比较先执行，而后于这个命令的必须后执行。

volatile没有原子性
volatile似乎是有时候可以代替简单的锁，volatile仅仅用来保证该变量对所有线程的可见性，但不保证原子性。不要将volatile用在getAndOperate场合（这种场合不是原子操作，需要再加锁），仅仅set或者get等操作的场景是适合volatile的，因为非原子操作情况下，代码可能被拆分为多个原子操作，多步操作的情况下就无法保证变量的线程安全，在中间过程中可能在其他线程中被修改。
（参考：https://www.cnblogs.com/rainwang/p/4398488.html）

静态内部类

public class Singleton {
    
    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonHolder.mSingleton;
    }

    private static class SingletonHolder{
        private static Singleton mSingleton = new Singleton();
    }

}

这种方式主要利用的ClassLoader加载类只会加载一次的特性以及通过内部静态类去持有单例的对象，保证了单例只会是唯一的，只会初始化一次，同时在调用getInstance方法时才会去加载SingletonHolder类以及实例化单例对象。

Android中用到的单例模式

不管是Android源码，还是各种依赖库框架都经常会使用到单例模式。

EventBus#getDafult()

  private static volatile EventBus defaultInstance;
  public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}

InputMethodManager#getInstance()

    static InputMethodManager sInstance;
    public static InputMethodManager getInstance() {
        synchronized (InputMethodManager.class) {
            if (sInstance == null) {
                try {
                    sInstance = new InputMethodManager(Looper.getMainLooper());
                } catch (ServiceNotFoundException e) {
                    throw new IllegalStateException(e);
                }
            }
            return sInstance;
        }
    }