Java设计模式之单例模式

单例模式

什么是单例模式

保证整个系统中一个类只有一个对象的实例，实现这种功能的方式就叫单例模式。

为什么要用单例模式

比如：大家都要喝水，但是没必要每人家里都打一口井是吧，通常的做法是整个村里打一个井就够了，大家都从这个井里面打水喝。

对应到我们计算机里面，像日志管理、打印机、数据库连接池、应用配置。

就像日志管理，如果多个人同时来写日志，你一笔我一笔那整个日志文件都乱七八糟，如果想要控制日志的正确性，那么必须要对关键的代码进行上锁，只能一个一个按照顺序来写，而单例模式只有一个人来向日志里写入信息方便控制，避免了这种多人干扰的问题出现。

实现单例模式的思路

• 构造私有：如果要保证一个类不能多次被实例化，那么我肯定要阻止对象被new 出来，所以需要把类的所有构造方法私有化。
• 静态方法返回实例：因为外界就不能通过new来获得对象，所以我们要通过提供类的方法来让外界获取对象实例。
• 确保对象只有一个：只对类进行一次实例化，以后都直接获取第一次实例化的对象。

实现方式

• 饿汉式单例

  类加载的时候就创建了实例
  优点：类加载的时候创建一次实例，避免了多线程同步问题

  缺点：即使单例没被用到也会创建，浪费内存

  public class Singleton {
      private static Singleton instance = new Singleton();
      //构造器私有
      private Singleton() { }
      //静态方法返回实例
      public static Singleton getInstance() {
          return instance; 
      }
  }
  或者
  
  public class Singleton {
      private static Singleton instance = null;
      static {
          instance = new Singleton();
      }
      private Singleton() { }
      public static Singleton getInstance() {
          return this.instance; 
      }
  }
  

  这种模式是最简单最省心的，不足的地方是容易造成资源上的浪费。

  它是线程安全的。

  Java 的类只会初始化一次（这次初始化是初始化静态变量跟静态常量，运行时常量不包含在内）并且是线程安全的（由 JVM 保证），初始化的顺序是有父类优先初始化父类的 filed 跟静态代码块，然后是接着初始化子类 filed 跟静态代码块，filed 跟静态代码块的初始化顺序是根据你定义的顺序初始化。

  而触发类初始化的触发条件分别是：调用静态变量、调用静态方法、构建类实例、对静态变量进行赋值、反射获取 Class信息、初始化一个类的子类、JVM 启动标记是启动类的类。

  最后，恶汉模式因为静态变量是在初始化的时候赋值，而类初始化是线程安全的，不存在多个线程初始化多次的问题，因此是线程安全的。

• 懒汉式

  因为饿汉模式可能会造成资源浪费的问题，所以就有了懒汉模式，懒汉模式的意思是，我先不创建类的对象实例，等你需要的时候我再创建。

  public class Singleton {
      private static Singleton instance = null;
      private Singleton() { }
      public static Singleton getInstance() {
            if (instance == null) {
                  instance = new Singleton();
            }
          return instance;
      }
  }
  

  优点：需要时才去创建
  缺点：没有考虑线程安全问题，多个线程并发调用getInstance，可能会创建多个实例

  解决线程安全问题的懒汉模式：

  public class Singleton {
      private static Singleton instance = null;
      private Singleton() { }
      public static Synchronized Singleton getInstance() {
            if (instance == null) {
                  instance = new Singleton();
            }
          return instance;
      }
  }
  //缺点：性能问题，添加了synchronized的函数比一般方法慢得多，若多次调用getInstance，则累积的性能损耗特别大。
  

• 双重校验锁(解决性能问题方案一)

  public class Singleton {
      private static Singleton instance = null;
      private Singleton() { }
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized(Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }
  //大部分情况下，同步代码块都不会执行到，提高了程序的性能。
  
  //有一种情况，两个线程ThreadA，ThreadB，如果threadA执行到了第一个if条件判断，instance = null；ThreadB也执行到了if条件判断instance = null，所以A和B会依次执行同步代码块里的代码。为了避免创建两个实例，因此又在同步代码块里添加了if条件进行二重检验。
  

  隐患：

  双检测锁定的方式 是只有当对象未创建的时候才对请求加锁，对象创建以后都不会上锁，这样有效的提升了程序的效率，也可以保证只会创建一个对象的实例。

  DCL(Double Check Lock)是完美的解决了单例模式中性能和资源浪费的问题，但是DCL在并发情下也会存在一个问题，因为Jvm指令是乱序的；

  情况如下：

  线程1调用getInstance 获取对象实例，因为对象还是空未进行初始化，此时线程1会执行new Singleton()进行对象实例化，而当线程1的进行new Singleton()的时候JVM会生成三个指令。

  指令1:分配对象内存。

  指令2:调用构造器，初始化对象属性。

  指令3:构建对象引用指向内存。

  因为编译器会自作聪明的对指令进行优化， 指令优化后顺序会变成这样:

  1、执行指令1：分配对象内存，

  2、执行指令3：构建对象引用指向内存。

  3、然后正好这个时候CPU 切到了线程2工作，而线程2此时也调用getInstance获取对象，那么线程2将执行下面这个代码 if (singleton == null)，此时线程2发现对象不为空（因为线程1已经创建对象引用并分配对象内存了），那么线程2会得到一个没有初始化属性的对象（因为线程1还没有执行指令2）。

  所以在这种情况下，双检测锁定的方式会出现DCL失效的问题。

  JDK5的修正：以上是双重校验锁失效的原因，不过在JDK1.5之后的版本添加了volatile关键字。

  1、volatile的一个语义是禁止指令重排序优化，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免了上述问题。

  2、Java中的volatile变量是什么？

  （1）关键字的作用有两个：

  ​ ①多线程主要围绕可见性和原子性两个特性展开，使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到的volatile变量，一定是最新的数据。

  ​ ②代码底层执行的顺序是Java代码–>字节码–>根据字节码执行对应的C/C++代码–>C/C++代码被编译成汇编语言–>和硬件电路交互。实际中，为了获取更好的性能，JVM可能会对指令进行重排序，多线程下可能会出现一些意想不到的问题。使用volatile则会禁止语义重排序，也一定程度上降低了代码执行效率。实践角度而言，volatile的一个重要作用就是和CAS结合，保证了原子性。

  （2）volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其他线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生。

  代码如下：

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

• 静态内部类(解决性能问题方案二)

  public class StaticSingleton {
      private StaticSingleton() {}
      private static class SingletonHolder {
          private static StaticSingleton INSTANCE = new StaticSingleton();
      }
  
      public static StaticSingleton getInstance() {
          return SingletonHolder.INSTANCE;
      }
  }
  //静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。
  

  类的初始化和实例化不同

  类的初始化：是完成程序执行前的准备工作。在这个阶段，静态的（变量，方法，代码块）会被执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。
  类的实例化：是指创建一个对象的过程。这个过程中会在堆中开辟内存，将一些非静态的方法，变量存放在里面。在程序执行的过程中，可以创建多个对象，既多次实例化。每次实例化都会开辟一块新的内存。

• 枚举

  class Singleton{
  }
  
  public enum Singleton {
      INSTANCE;
      private Singleton instance;
      Singleton() {
          instance = new Singleton();
      }
      public Singleton getInstance() {
          return instance;
      }
  }
  

  上面的类Singleton是我们要应用单例模式的资源，具体可以表现为网络连接，数据库连接，线程池等等。
  获取资源的方式很简单，只要 Singleton.INSTANCE.getInstance() 即可获得所要实例。下面我们来看看单例是如何被保证的：
  首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。
  也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。