Java设计模式 —— 单例模式

6 单例模式

6.1 单例模式概述

Singleton Patter：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

单例模式有3个要点：

• 该类只能有一个实例
• 该类必须自行创建这个实例
• 该类必须向整个系统提供这个实例

单例模式结构图如下所示：

6.2 单例模式实现

6.2.1 单例类

public class Singleton {
  // 静态私有成员变量
  private static Singleton instance = null;

  // 私有构造函数, 类外无法创建该类实例
  private Singleton() {
  }

  // 静态公有访问方法
  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }

    return instance;
  }
}

6.2.2 客户端调用

public class Client {
  public static void main(String[] args) {
    Singleton s1 = Singleton.getInstance();
    Singleton s2 = Singleton.getInstance();

    // 判断两个对象是否是同一实例
    if (s1 == s2) {
      System.out.println("s1 and s2 are the same.");
    }
    else {
      System.out.println("s1 is different from s2.");
    }
  }
}

// Result
>>> s1 and s2 are the same.

单例模式的实现过程需要注意以下3点：

• 构造函数私有
• 提供一个类型为自身的静态私有成员变量
• 提供一个公有的静态工厂方法

6.3 饿汉式单例

饿汉式单例类是最简单的单例类，该模式结构图如下：

从图中可以看初，在定义静态变量时实例化单例类，因此在类加载时单例对象就已创建。

public class EagerSingleton {
  private static final EagerSingleton instance = new EagerSingleton();
  private EagerSingleton() {}

  public static EagerSingleton getInstance() {
    return instance;
  }
}

6.4 懒汉式单例

6.4.1 懒汉式单例概述

与饿汉式单例不同的是，懒汉式单例会在第一次被引用时将自己实例化，在懒汉式单例类被加载时不会实例化。懒汉式单例结构图如下：

懒汉式单例在第一次调用 getInstance() 方法时实例化，在类加载时并不实例化，这种技术称为延迟加载(Lazy load)。

6.4.2 双重检查锁定

Step1：为了避免多个线程同时调用 getInstance() 方法，可以使用 synchronized 关键字

public class LazySingleton {
  private static LazySingleton instance = null;
  private LazySingleton() {}

  synchronized public static LazySingleton getInstance() {
    if (instance == null) {
      instance = new LazySingleton();
    }
    return instance;
  }
}

Step2：在 Step1 的懒汉式单例中，在 getInstance() 方法前加了关键字进行线程锁定，以处理多个线程访问的问题。但是每次方法调用时都需要进行线程锁定判断，导致性能大大降低。因此可以对上述代码进行改进，无须对整个 geInstance() 方法锁定，只需对代码块 instance = new LazySingleton() 锁定即可。

public class LazySingleton {
  private static LazySingleton instance = null;
  private LazySingleton() {}

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

Step3：Step2 中代码实现貌似解决了线程安全问题，但事实并非如此，还是会存在创建多个单例对象的情况，原因如下：

假如线程A和线程B都在调用 getInstance() 方法，此时 instance 对象为 null，两个均能通过 if 判断语句。假如线程A拿到了类锁执行实例创建，线程B处于排队等待，当线程A执行完毕后，线程B并不知道实例已经创建，将继续创建实例，导致产生多个单例对象。

进一步修改代码，在 synchronized 中再进行一次判断，这种方式称为双重锁定检查。

public class LazySingleton {
  // volatile关键字，确保变量修改对其他线程可见
  private volatile static LazySingleton instance = null;
  private LazySingleton() {}

  public static LazySingleton getInstance() {
    // 第一重判断
    if (instance == null) {
      synchronized(LazySingleton.class) {
        // 第二重判断
        if (instance == null) {
          instance = new LazySingleton();
        }
      }
    }
    return instance;
  }
}

6.5 静态内部类实现单例模式

饿汉式单例类在类加载时就实例化，不管将来用不用始终占用内存；懒汉式单例类线程安全控制繁琐，性能受到影响；饿汉式和懒汉式单例都存在一些问题，为了克服这些问题，在 Java 中可以通过 Initialization on Demand Holder(IoDH) 技术来实现。

在 IoDH 中，需要在单例类中新增一个静态内部类，在该内部类创建单例对象。

public class Singleton {
  private Singleton() {}

  private static class HoldClass {
    private final static Singleton instance = new Singleton();
  }

  public static Singleton getInstance() {
    return HoldClass.instance;
  }
}

由于静态单例对象不是 Singleton 的成员变量，因此在加载 Singleton 类时不会将其实例化，第一次调用 getInstance() 方法时将加载内部类 HoldClass 初始化 instance，由 Java 虚拟机来保证其线程安全性，确保该成员变量只能初始化一次；且由于 getInstance() 方法没有任何线程锁定，因此不会对其性能造成影响。

通过 IoDH 既可以实现延迟加载，又可以保证线程安全，不失为一种最好的 Java 语言单例模式的实现方式，其缺点是与编程语言本身的特性有关。

6.6 单例模式优/缺点

单例模式的优点主要如下：

• 在系统中只存在一个对象，可以节约系统资源
• 单例类封装了它的唯一实例，可以严格控制该实例的访问方式

单例模式的缺点主要如下：

• 单例模式中没有抽象层，扩展困难
• 单例类既提供业务方法，又提供对象创建方法，将对象的创建和对象的使用耦合在一起，职责过重，有违单一职责原则