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 单例模式优/缺点
单例模式的优点主要如下：
- 在系统中只存在一个对象，可以节约系统资源
- 单例类封装了它的唯一实例，可以严格控制该实例的访问方式
单例模式的缺点主要如下：
- 单例模式中没有抽象层，扩展困难
- 单例类既提供业务方法，又提供对象创建方法，将对象的创建和对象的使用耦合在一起，职责过重，有违单一职责原则