单例模式

单例模式（Singleton）相信大家或多或少都用过，代码量不多，看起来也很简单，但是里面的学问却不简单。面试中经常会问到单例模式相关的问题，但是如果你只停留在最简单的使用上，那么想让面试官满意就很难了。
单例模式用来保证应用中有且仅有一个实例，也是Android中用的较多的一种设计模式。单例模式有很多使用场景，例如，当一个对象需要频繁创建、销毁时，为了减少内存开销，可以使用单例模式。
单例模式最关键的两点：
**1、私有构造方法
2、公有的对外调用接口
**

单例模式分为两种，饿汉式和懒汉式。常见简单写法如下所示：

一、饿汉式

 public class Singleton{
      private static final Singleton instance = new Singleton();  //声明为static和final，第一次加载类到内存中时就会初始化
      private Singleton(){}
      public static Singleton newInstance(){
             return instance; 
      }
}

二、懒汉式（线程不安全）

 public class Singleton{
      private static Singleton instance = null;
      private Singleton(){}
      public static Singleton newInstance(){
              if(instance == null){
                    instance = new Singleton();   //方法被调用的时候才生成实例
                                   } 
              return instance;
         }
}

三、饿汉式与懒汉式的区别

对比这两种方式的代码我们可以看出，饿汉式在类第一次加载进内存就实例化了，而懒汉式使用了懒加载模式，当方法被调用时类对象的实例时才生成。根据名称也很好理解，饿汉式很饿，刚一加载进内存，不等你说，就迫不及待生成“食物”（类的实例）充饥；懒汉式很懒，需要的时候你催我（调用获取实例函数），我才给你生成。

四、饿汉式与懒汉式的适用场景

饿汉式是最简单的实现方式，适合那些在初始化时就要用到单例的情况，如果单例对象初始化非常快，而且占用内存非常小的时候这种方式是比较合适的，可以直接在应用启动时加载并初始化。饿汉式的创建方式在一些场景中无法使用：譬如 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance() 之前必须调用某个方法设置参数给它，那么这种单例写法就无法使用了。
　　懒汉式将单例的初始化操作延迟到需要的时候才进行，若某个单例用的次数不是很多，但是这个单例提供的功能又非常复杂，而且加载和初始化要消耗大量的资源，这个时候使用懒汉式就比使用饿汉式合适的多。

五、线程安全的懒汉式

不知道大家发现没有，在上面的代码中关于懒汉式的写法存在一个致命的缺点，那就是在多线程的情况下无法正常使用，当多个线程同时调用getInstance()方法时，就会创建多个Singleton实例，因此这种写法是线程不安全的。而饿汉式只会在Singleton类加载进内存时实例化一次，不会出现多次实例化的问题，也就不存在线程安全问题。

1、同步锁

为了解决懒汉式的线程安全问题，最简单的方法是使用同步锁synchronized。

public class Singleton {
     private static Singleton instance = null;
     private Singleton(){ }
     public static Singleton getInstance() {
              synchronized (Singleton.class) {//防止多线程同时进入造成instance被多次实例化
                  if (instance == null) {
                       instance = new Singleton();
                                } 
                    }
              return instance;
        }
}

2、双重检验锁（Double-Check）

这样做虽然解决了线程安全问题，但是并不高效，因为在任何时候只能有一个线程调用 getInstance() 方法。我们的同步并不是要防止多个线程同时调用getInstance()，而是防止多个线程同时实例化instatnce。因此，可以在实例化instatnce的地方进行同步，如下所示：

public class Singleton {
     private static Singleton instance = null; 
     private Singleton(){ }
     public static Singleton getInstance() {
          if (instance == null) { //-------------------Single Checked
           // 若实例创建了，则不需要同步了，直接返回instance即可
                synchronized (Singleton.class) { //未创建实例，加锁
                     if (instance == null) { //----------------------Double Checked
                     //若被同步的线程中有一个线程创建了实例，那么别的线程就不用创建了
                              instance = new Singleton(); 
                          }
                   } 
           }
           return instance;
      }
}

其中第二次Check是因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

3、懒汉式的最佳写法

上面的Double-check看似完美了，但是却存在问题，因为 instance = new Singleton();这句代码并不是原子操作。在JVM中这句代码大概做了下面 3 件事情：
（1）给 instance 分配内存
（2）调用 Singleton 的构造函数来初始化成员变量，形成实例
（3）将instance对象指向分配的内存空间（执行完这步 instance 才为非 null）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第（2）步和第（3）步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被其他线程抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以其他线程会直接返回 instance，然后使用这个未初始化的instance，就会顺理成章地报错。
解决办法也很简单，只需要将 instance 变量声明成 volatile 就可以了。我们一般使用volatile关键字有两个功能：
（1）可见性：volatile关键字修饰的变量不会在多个线程中存在副本，每次都是直接从内存中读取。
（2）禁止指令重排序优化。在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。

public class Singleton {
     private volatile static Singleton instance = null; //声明成 volatile
     private Singleton(){ }
     public static Singleton getInstance() {
          if (instance == null) { //-------------------Single Checked
           // 若实例创建了，则不需要同步了，直接返回instance即可
                synchronized (Singleton.class) { //未创建实例，加锁
                     if (instance == null) { //----------------------Double Checked
                     //若被同步的线程中有一个线程创建了实例，那么别的线程就不用创建了
                              instance = new Singleton(); 
                          }
                   } 
           }
           return instance;
      }
}

六、静态内部类

public class Singleton {
     private static class SingletonHolder {//只有加载内部类的时候才初始化
          private static final Singleton INSTANCE = new Singleton();
     } 
     private Singleton (){}
     public static final Singleton getInstance() { //只有在getInstance()被调用的时候才被真正创建
          return SingletonHolder.INSTANCE; 
     }
}

这种写法仍然使用JVM本身机制保证了线程安全问题。
　　由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。这种写法即解决了饿汉式不能延迟加载的缺陷，又解决了懒汉式线程安全的问题，也是《Effective Java》上所推荐的写法。

七、枚举（Enum）

public enum Singleton{ 
      INSTANCE; //定义一个枚举的元素，它就是Singleton的一个实例 
}

我们可以通过Singleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。默认枚举实例的创建是线程安全的(创建枚举类的单例在JVM层面也是能保证线程安全的)，所以不需要担心线程安全的问题，而且还能防止反序列化导致重新创建新的对象。所以理论上枚举类来实现单例模式是最简单的方式。但由于大多数人不太熟悉，用这种方法写的人不多。

八、总结

一般来说，单例模式有五种写法：饿汉、懒汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，文章开头给出的第一种懒汉式方法不算正确的写法。
　　在我们日常实践中，一般情况下直接使用饿汉式就好了，如果明确要求要懒加载，则推荐使用静态内部类，如果涉及到反序列化创建对象时，可以使用枚举的方式来实现单例。但是在很多的面试中，线程安全的懒汉式是最常考察的，我们需要好好掌握Double-Check的写法，注意关键字volatile的使用。
参考文章：
1、http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/
2、http://stormzhang.com/designpattern/2016/03/27/android-design-pattern-singleton/