设计模式之单例模式全解析

单例模式，是一种常用的软件设计模式，其主要作用是保证某一个类只能有一个该类的实例。解决的问题就是一个全局使用的类频繁地创建与销毁。在当您想控制实例数目，节省系统资源的时候您就可以使用到它了。
单例模式有三个要点：
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。

下面我就详细介绍下单例的六种写法与其各自的特点：
饿汉/懒汉/懒汉线程安全/DCL/静态内部类/枚举

1. 饿汉模式单例
首先上代码：

public class HungurySingleton{
  private static final HungurySingleton mHungurySingleton=new HungurySingleton();

  private HungurySingleton(){}

  public static HungurySingleton getInstance(){
       return mHungurySingleton；
  }
}

代码比较简单，首先声明私有的构造方法，这样保证其它类不能直接构造该类的实例。然后在类中创建该类的私有实例，最后创建外部的接口获取该实例。
注意：保证创建该类的私有实例与获取接口都必须是静态的。
不足：因为是静态的，所以JVM虚拟机就会在任何需要使用到该单例时都会被创建，不能对实例做延时加载。
优化：懒汉模式。

2.懒汉模式
首先上代码：

public class LazySingleton{
  private static LazySingleton mLazySingleton;

  private LazySingleton(){}

  public static LazySingleton getInstance(){
      //第一次创建时候初始化
      if(mLazySingleton==null){
         mLazySingleton=new LazySingleton();
      }
       return mLazySingleton；
  }
}

如上代码所示，我们不再一开始就进行实例的创建，而是在需要使用到该实例的时候才创建，这样就解决了饿汉模式下的缺点。但熟悉Java多线程都知道，这样的实现是无法保证在多线程的情况下实例是唯一的。
不足：无法保证在多线程并发的情况下实例是唯一的。多线程下，懒汉模式是失效的。
优化：懒汉线程安全模式。

3.懒汉线程安全模式
首先上代码：两种方式

public class LazySafeSingleton{
  private static LazySafeSingleton mLazySafeSingleton;

  private LazySingleton(){}

  public static LazySingleton getInstance(){
      //同步代码块实现
      synchronized(LazySingleton.class){
          if(mLazySingleton==null){
             mLazySafeSingleton=new LazySafeSingleton();
          }
      }
      return mLazySingleton；
  }
}

public class LazySafeSingleton{
  private static LazySafeSingleton mLazySafeSingleton;

  private LazySingleton(){}
  //方法名中声明synchronized关键字
  public static synchronized LazySingleton getInstance(){
          if(mLazySingleton==null){
             mLazySafeSingleton=new LazySafeSingleton();
          }
      return mLazySingleton；
  }
}

这样保证了线程安全。
不足： 它会有性能上的缺陷，由于使用了synchronized关键字
优化： DCL模式

4.DCL模式单例
又称双重检验锁机制，首先上代码：

public class LazySafeSingleton{
  private static LazySafeSingleton mLazySafeSingleton;

  private LazySingleton(){}

  public static LazySingleton getInstance(){
      //同步代码块实现
      if(mLazySingleton==null){
          synchronized(LazySingleton.class){
              if(mLazySingleton==null){
                 mLazySafeSingleton=new LazySafeSingleton();
              }
          }
      }
      return mLazySingleton；
  }
}

这种模式使用同步块加锁的方法解决懒汉安全模式的性能问题，它会有两次检查mLazySingleton是否为空。
不足： mLazySafeSingleton=new LazySafeSingleton(); 使用new创建实例不是一个原子操作。（具体什么是原子操作，我也不知道）
这句代码的逻辑是：第一步给实例分配内存，第二步使用New关键字，调用构造方法实例化我们的对象，第三步将我们的对像指向分配的内存空间。但我们的JVM的虚拟机存在指令重排序的优化。什么意思呢，就是上述三个步骤不一定会按照这个一二三步骤顺序执行。这时候会造成线程不安全，报错。
解决办法：将实例变量设置为volatile

private static volatile LazySafeSingleton mLazySafeSingleton;

volatile可以禁止JVM的指令重排序的优化。

5.静态内部类模式单例
首先上代码：

public class StaticInnerSingleton{

  private StaticInnerSingleton(){}

  public static StaticInnerSingleton getInstance(){    
      return Holder.mStaticInnerSingleton;
  }
  //静态内部类
  private static  class Holder{
    private static final StaticInnerSingleton mStaticInnerSingleton=new StaticInnerSingleton();
  }
}

JVM提供给我们提供同步控制：static 与 final。它们修饰的变量具有线程安全的特性。在内部类中创建我们的实例，只要我们不使用这个内部类，就不会加载该内部类，就不会创建我们需要的实例。只有我们第一次调用getInstance()这个方法时，才会加载内部类并初始化类的对象。这样能确保线程安全同时能确保类的唯一性。

这种方式是我们比较推荐的创建单例模式的方式。
优点： 利用类中静态变量的唯一性。

1. JVM本身的机制保证了我们线程的安全。
2. 没有使用synchronized关键字，提升了我们的性能。
3. Holder是私有的，除了getInstance()方法，外部没有其它方法可以访问。

6.枚举
首先上代码：

public enum EnumSingleton{
   INSTANCE; //定义一个枚举单元，这就是一个实例
   public void doSomething(){
      ...
   }
}

代码相较于静态内部类的形式还要少。这是一个大优点。
当然这里可以再添加一些实例，或一些实例方法。但需要注意的是，当只有一个枚举单元时，这个实例是线程安全的，如果添加了其它的实例，就必须要保证它们是线程安全的操作。
优点：代码写法简单。

以上，就是所有单例的所有表达方法。

总结：
饿汉：无法对instance进行延迟加载
懒汉：多线程并发下无法保证实例的唯一性
懒汉线程安全：使用synchronized关键字导致性能缺陷
DCL：JVM编译器的指令重排序
静态内部类/枚举：延迟加载，线程安全，性能优势

以上内容总结于慕课网 BAT大神经验只谈——深入解析Android面试