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

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

下面我就详细介绍下单例的六种写法与其各自的特点： 饿汉/懒汉/懒汉线程安全/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()这个方法时，才会加载内部类并初始化类的对象。这样能确保线程安全同时能确保类的唯一性。

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

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

6.枚举首先上代码：

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

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

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

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