---
title: 设计模式之单例模式
date: 2015-06-03 09:24:00
order: 06
categories:
  - 设计
  - 设计模式
tags:
  - 设计
  - 设计模式
permalink: /pages/1a7f3b3a/
---

# 设计模式之单例模式

## 意图

**单例模式**（Singleton）是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

**单例** （Singleton） 类声明了一个名为 `get­Instance` 获取实例的静态方法来返回其所属类的一个相同实例。

单例的构造函数必须对客户端 （Client） 代码隐藏。 调用 `get­Instance` 方法必须是获取单例对象的唯一方式。

所有单例的实现都包含以下两个相同的步骤：

- **将默认构造函数设为私有**， 防止其他对象使用单例类的 `new`运算符。
- **新建一个静态构建方法作为构造函数**。 该函数会 “偷偷” 调用私有构造函数来创建对象， 并将其保存在一个静态成员变量中。 此后所有对于该函数的调用都将返回这一缓存对象。

如果你的代码能够访问单例类， 那它就能调用单例类的静态方法。 无论何时调用该方法， 它总是会返回相同的对象。

单例模式的优点：

- ✔️️️ 你可以保证一个类只有一个实例。
- ✔️️️ 你获得了一个指向该实例的全局访问节点。
- ✔️️️ 仅在首次请求单例对象时对其进行初始化。

单例模式的缺点：

- ❌ 违反了*单一职责原则*。 该模式同时解决了两个问题。
- ❌ 单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。
- ❌ 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
- ❌ 单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。

## 适用场景

- 如果程序中的某个类对于所有客户端只有一个可用的实例， 可以使用单例模式。
  ⚡ 单例模式禁止通过除特殊构建方法以外的任何方式来创建自身类的对象。 该方法可以创建一个新对象， 但如果该对象已经被创建， 则返回已有的对象。
- 如果你需要更加严格地控制全局变量， 可以使用单例模式。
  ⚡ 单例模式与全局变量不同， 它保证类只存在一个实例。 除了单例类自己以外， 无法通过任何方式替换缓存的实例。

请注意， 你可以随时调整限制并设定生成单例实例的数量， 只需修改 `获取实例` 方法， 即 `getInstance` 中的代码即可实现。

举例来说，一些资源管理器常常设计成单例模式。

在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个 Printer Spooler， 以避免两个打印作业同时输出到打印机中。

每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。任务管理器中难以启动两个相同的 task。

## 结构

![img](https://raw.githubusercontent.com/dunwu/images/master/snap/20210517200626.png)

1. **单例** （Singleton） 类声明了一个名为 `get­Instance`获取实例的静态方法来返回其所属类的一个相同实例。
   - 单例的构造函数必须对客户端 （Client） 代码隐藏。 调用 `获取实例`方法必须是获取单例对象的唯一方式。

## 伪代码

在本例中， 数据库连接类即是一个**单例**。

该类不提供公有构造函数， 因此获取该对象的唯一方式是调用 `获取实例`方法。 该方法将缓存首次生成的对象， 并为所有后续调用返回该对象。

```java
// 数据库类会对`getInstance（获取实例）`方法进行定义以让客户端在程序各处
// 都能访问相同的数据库连接实例。
class Database is
    // 保存单例实例的成员变量必须被声明为静态类型。
    private static field instance: Database

    // 单例的构造函数必须永远是私有类型，以防止使用`new`运算符直接调用构
    // 造方法。
    private constructor Database() is
        // 部分初始化代码（例如到数据库服务器的实际连接）。
        // ...

    // 用于控制对单例实例的访问权限的静态方法。
    public static method getInstance() is
        if (Database.instance == null) then
            acquireThreadLock() and then
                // 确保在该线程等待解锁时，其他线程没有初始化该实例。
                if (Database.instance == null) then
                    Database.instance = new Database()
        return Database.instance

    // 最后，任何单例都必须定义一些可在其实例上执行的业务逻辑。
    public method query(sql) is
        // 比如应用的所有数据库查询请求都需要通过该方法进行。因此，你可以
        // 在这里添加限流或缓冲逻辑。
        // ...

class Application is
    method main() is
        Database foo = Database.getInstance()
        foo.query("SELECT ...")
        // ...
        Database bar = Database.getInstance()
        bar.query("SELECT ...")
        // 变量 `bar` 和 `foo` 中将包含同一个对象。
```

## 案例

**使用示例：** 许多开发者将单例模式视为一种反模式。 因此它在 Java 代码中的使用频率正在逐步减少。

尽管如此， Java 核心程序库中仍有相当多的单例示例：

- [`java.lang.Runtime#getRuntime()`](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime--)
- [`java.awt.Desktop#getDesktop()`](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
- [`java.lang.System#getSecurityManager()`](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)

**识别方法：** 单例可以通过返回相同缓存对象的静态构建方法来识别。

### 数据库连接类

数据库连接类即是一个**单例**。

该类不提供公有构造函数， 因此获取该对象的唯一方式是调用 `获取实例`方法。 该方法将缓存首次生成的对象， 并为所有后续调用返回该对象。

```java
// 数据库类会对`getInstance（获取实例）`方法进行定义以让客户端在程序各处
// 都能访问相同的数据库连接实例。
class Database is
    // 保存单例实例的成员变量必须被声明为静态类型。
    private static field instance: Database

    // 单例的构造函数必须永远是私有类型，以防止使用`new`运算符直接调用构
    // 造方法。
    private constructor Database() is
        // 部分初始化代码（例如到数据库服务器的实际连接）。
        // ...

    // 用于控制对单例实例的访问权限的静态方法。
    public static method getInstance() is
        if (Database.instance == null) then
            acquireThreadLock() and then
                // 确保在该线程等待解锁时，其他线程没有初始化该实例。
                if (Database.instance == null) then
                    Database.instance = new Database()
        return Database.instance

    // 最后，任何单例都必须定义一些可在其实例上执行的业务逻辑。
    public method query(sql) is
        // 比如应用的所有数据库查询请求都需要通过该方法进行。因此，你可以
        // 在这里添加限流或缓冲逻辑。
        // ...

class Application is
    method main() is
        Database foo = Database.getInstance()
        foo.query("SELECT ...")
        // ...
        Database bar = Database.getInstance()
        bar.query("SELECT ...")
        // 变量 `bar` 和 `foo` 中将包含同一个对象。
```

### 懒汉式

懒汉式的实现思路是：你不找懒汉，懒汉根本就懒得去初始化自己。

`instance` 初始时没有初始化，只有当第一次调 `getInstance()` 时才创建实例。

**缺点**：当有两个线程调 `getInstance()` 方法，当它们同时执行到 `if (null == instance)` 这行代码，`instance` 为 `null`。

继续向下执行，会生成两个实例，违背了单例模式的初衷。

```java
public class LazySingleton {
    private LazySingleton() {
        System.out.println("Singleton()");
    }

    private static LazySingleton instance = null;

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

### 饿汉式

懒汉式的实现思路是：饿汉根本等不及别人来找他，不管三七二十一先初始化了自身的实例，生怕自己饿着了。

类默认先直接初始化一个实例，以后调用 `getInstance()` 总是返回这个已创建好的实例。

**缺点**：在没有必要获取实例时，已经预先产生了开销。

**优点**：规避了懒汉式方法的线程问题，不用显示编写线程安全代码。

```java
public class HungerSinleton {
    private HungerSinleton() {
        System.out.println("Singleton()");
    }

    private static HungerSinleton instance = new HungerSinleton();

    public static HungerSinleton getInstance() {
        return instance;
    }
}
```

### 双重锁的形式

如果既不想在没有调用 `getInstance(`) 方法时产生开销，又不想发生线程安全问题，就可以采用双重锁的形式。

```java
public class SyncSingleton {
    private SyncSingleton() {
        System.out.println("Singleton()");
    }

    private static SyncSingleton instance = null;

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

> **注：在外面判断了 instance 实例是否存在，为什么在锁定后又要在内部又判断一次？**
>
> 这是因为，如果 `instance` 为 `null` 时有两个线程同时调用 `getInstance()`，由于 `synchronized` 机制，只允许一个线程进入，另一个需要等待。
>
> 这时如果没有第二道 `instance` 是否为 `null` 的判断，就可能发生第一个线程创建一个实例，而第二个线程又创建一个实例的情况。

## 与其他模式的关系

- [外观模式](https://refactoringguru.cn/design-patterns/facade)类通常可以转换为[单例模式](https://refactoringguru.cn/design-patterns/singleton)类， 因为在大部分情况下一个外观对象就足够了。
- 如果你能将对象的所有共享状态简化为一个享元对象， 那么[享元模式](https://refactoringguru.cn/design-patterns/flyweight)就和[单例](https://refactoringguru.cn/design-patterns/singleton)类似了。 但这两个模式有两个根本性的不同。
  1. 只会有一个单例实体， 但是*享元*类可以有多个实体， 各实体的内在状态也可以不同。
  2. *单例*对象可以是可变的。 享元对象是不可变的。
- [抽象工厂模式](https://refactoringguru.cn/design-patterns/abstract-factory)、 [生成器模式](https://refactoringguru.cn/design-patterns/builder)和[原型模式](https://refactoringguru.cn/design-patterns/prototype)都可以用[单例](https://refactoringguru.cn/design-patterns/singleton)来实现。

## 参考资料

- [《Head First 设计模式》](https://book.douban.com/subject/2243615/)
- [《大话设计模式》](https://book.douban.com/subject/2334288/)
- [设计模式教程](https://refactoringguru.cn/design-patterns/catalog)