单例设计模式

ゞ浴缸里的玫瑰 2021-09-18 07:32 305阅读 0赞

本文为极客时间《设计模式之美》的读书笔记

# 单例模式 #

一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。

# 使用场景 #

## 1.实现对象锁的线程安全 ##

public class Logger {
    
       //FileWriter 的write操作加了对象级别的锁
    
      private FileWriter writer;
    
      public Logger() {
    
        File file = new File("/Users/wangzheng/log.txt");
    
        writer = new FileWriter(file, true); //true表示追加写入
    
      }
    
      public void log(String message) {
    
        writer.write(message);
    
      }
    
    }
    
    // Logger类的应用示例：
    
    public class UserController {
    
      private Logger logger = new Logger();
    
      public void login(String username, String password) {
    
        // ...省略业务逻辑代码...
    
        logger.log(username + " logined!");
    
      }
    
    }
    
    public class OrderController {
    
      private Logger logger = new Logger();
    
      public void create(OrderVo order) {
    
        // ...省略业务逻辑代码...
    
        logger.log("Created an order: " + order.toString());
    
      }
    
    }

![18721752-a71fc36fe432937c.png][]

image.png

以上代码是有问题的，像FileWriter.write这种使用对象锁进行保护共享变量的方式，一旦创建了多个FileWriter的实例，那么多线程之间每个FileWriter实例的锁对象都是不同的，无法保护共享变量，在上面这个代码里面会导致日志覆盖问题的发生。

上面代码中如果将Logger设计成一个单例，程序只允许创建一个Logger对象，所有的线程共享使用的这一个 Logger 对象，共享一个 FileWriter 对象，而 FileWriter 本身是对象级别线程安全的，也就避免了多线程情况下写日志会互相覆盖的问题。

public class Logger {
    
      private FileWriter writer;
    
      private static final Logger instance = new Logger();
    
      private Logger() {
    
        File file = new File("/Users/wangzheng/log.txt");
    
        writer = new FileWriter(file, true); //true表示追加写入
    
      }
    
      public static Logger getInstance() {
    
        return instance;
    
      }
    
      public void log(String message) {
    
        writer.write(mesasge);
    
      }
    
    }
    
    // Logger类的应用示例：
    
    public class UserController {
    
      public void login(String username, String password) {
    
        // ...省略业务逻辑代码...
    
        Logger.getInstance().log(username + " logined!");
    
      }
    
    }
    
    public class OrderController {  
    
      public void create(OrderVo order) {
    
        // ...省略业务逻辑代码...
    
        Logger.getInstance().log("Created a order: " + order.toString());
    
      }
    
    }

## 2.表示全局为一类 ##

从业务概念上，如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。

比如，配置信息类。在系统中，我们只有一个配置文件，当配置文件被加载到内存之后，以对象的形式存在，也理所应当只有一份。

再比如，唯一递增 ID 号码生成器，如果程序中有两个对象，那就会存在生成重复 ID 的情况，所以，我们应该将 ID 生成器类设计为单例。

import java.util.concurrent.atomic.AtomicLong;
    
    public class IdGenerator {
    
      // AtomicLong是一个Java并发库中提供的一个原子变量类型,
    
      // 它将一些线程不安全需要加锁的复合操作封装为了线程安全的原子操作，
    
      // 比如下面会用到的incrementAndGet().
    
      private AtomicLong id = new AtomicLong(0);
    
      private static final IdGenerator instance = new IdGenerator();
    
      private IdGenerator() {}
    
      public static IdGenerator getInstance() {
    
        return instance;
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }
    
    // IdGenerator使用举例
    
    long id = IdGenerator.getInstance().getId();

# 实现单例需注意的点 #

*  构造函数需要是 private 访问权限的，这样才能避免外部通过 new 创建实例；
 *  考虑对象创建时的线程安全问题；
 *  考虑是否支持延迟加载；
 *  考虑 getInstance() 性能是否高（是否加锁）。

# 单例的实现方式 #

## 1.饿汉式 ##

public class IdGenerator { 
    
      private AtomicLong id = new AtomicLong(0);
    
      private static final IdGenerator instance = new IdGenerator();
    
      private IdGenerator() {}
    
      public static IdGenerator getInstance() {
    
        return instance;
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }

采用饿汉式实现方式，将耗时的初始化操作，提前到程序启动的时候完成，这样就能避免在程序运行的时候，再去初始化导致的性能问题。

## 2.懒汉式 ##

public class IdGenerator { 
    
      private AtomicLong id = new AtomicLong(0);
    
      private static IdGenerator instance;
    
      private IdGenerator() {}
    
      //类级锁
    
      public static synchronized IdGenerator getInstance() {
    
        if (instance == null) {
    
          instance = new IdGenerator();
    
        }
    
        return instance;
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }

懒汉式的缺点也很明显，我们给 getInstance() 这个方法加了一把大锁（synchronzed），导致这个函数的并发度很低。量化一下的话，并发度是 1，也就相当于串行操作了。而这个函数是在单例使用期间，一直会被调用。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，那频繁加锁、释放锁及并发度低等问题，会导致性能瓶颈，这种实现方式就不可取了。

## 3.双重检测 ##

public class IdGenerator { 
    
      private AtomicLong id = new AtomicLong(0);
    
      private static IdGenerator instance;
    
      private IdGenerator() {}
    
      public static IdGenerator getInstance() {
    
        if (instance == null) { //这里先判断实例是否存在，只有不存在才进行锁保护的代码段，通过并发的角度看是提高锁的细粒度
    
          synchronized(IdGenerator.class) { // 此处为类级别的锁
    
            if (instance == null) {
    
              instance = new IdGenerator();
    
            }
    
          }
    
        }
    
        return instance;
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }

网上有人说，这种实现方式有些问题。因为指令重排序（jvm自动优化），可能会导致 IdGenerator 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化（执行构造函数中的代码逻辑），就被另一个线程使用了。

要解决这个问题，我们需要给 instance 成员变量加上 volatile 关键字，禁止指令重排序才行。实际上，只有很低版本的 Java 才会有这个问题。我们现在用的高版本的 Java 已经在 JDK 内部实现中解决了这个问题（解决的方法很简单，只要把对象 new 操作和初始化操作设计为原子操作，就自然能禁止重排序）。

## 4.静态内部类 ##

public class IdGenerator { 
    
      private AtomicLong id = new AtomicLong(0);
    
      private IdGenerator() {}
    
       //利用虚拟机的类初始化机制创建单例
    
      private static class SingletonHolder{
    
        private static final IdGenerator instance = new IdGenerator();
    
      }
    
      public static IdGenerator getInstance() {
    
        return SingletonHolder.instance;
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }

SingletonHolder 是一个静态内部类，当外部类 IdGenerator 被加载的时候，并不会创建 SingletonHolder 实例对象。只有当调用 getInstance() 方法时，SingletonHolder 才会被加载，这个时候才会创建 instance。instance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。

## 5.枚举 ##

这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。

public enum IdGenerator {
    
      INSTANCE;
    
      private AtomicLong id = new AtomicLong(0);
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }

# 单例模式的一些问题 #

## 1.单例对OOP特性不友好 ##

public class Order {
    
      public void create(...) {
    
        //...
    
        long id = IdGenerator.getInstance().getId();
    
        //...
    
      }
    
    }
    
    public class User {
    
      public void create(...) {
    
        // ...
    
        long id = IdGenerator.getInstance().getId();
    
        //...
    
      }
    
    }

IdGenerator 的使用方式违背了基于接口而非实现的设计原则，也就违背了广义上理解的 OOP 的抽象特性。

如果未来某一天，我们希望针对不同的业务采用不同的 ID 生成算法。比如，订单 ID 和用户 ID 采用不同的 ID 生成器来生成。为了应对这个需求变化，我们需要修改所有用到 IdGenerator 类的地方，这样代码的改动就会比较大。

public class Order {
    
      public void create(...) {
    
        //...
    
        long id = IdGenerator.getInstance().getId();
    
        // 需要将上面一行代码，替换为下面一行代码
    
        long id = OrderIdGenerator.getIntance().getId();
    
        //...
    
      }
    
    }
    
    public class User {
    
      public void create(...) {
    
        // ...
    
        long id = IdGenerator.getInstance().getId();
    
        // 需要将上面一行代码，替换为下面一行代码
    
        long id = UserIdGenerator.getIntance().getId();
    
      }
    
    }

对于OOP特性的不友好

*  抽象
    
     *  单例违反基于接口而非实现的原则，一旦代码逻辑发生变化，他的所有引用都需有变化。
 *  继承
    
     *  一般情况下，子类继承父类，子类的构造函数会隐式的调用父类的无参构造函数（构造中隐藏了supper）,一旦父类私有化构造后，子类无法继承父类的私有化的成员，导致其他类继承单例，直接编辑时报错，提示用户父类中没有可以使用的构造。

\[图片上传失败...(image-7685b9-1626650778550)\]

*  多态
    
     *  多态的实现方式有两种，接口和继承，但是单例一般都不是接口，且又不支持继承，那么自然就不支持多态了。

## 2.单例会隐藏类之间的依赖关系 ##

通过构造函数、参数传递等方式声明的类之间的依赖关系，我们通过查看函数的定义，就能很容易识别出来。但是，单例类不需要显示创建、不需要依赖参数传递，在函数中直接调用就可以了。如果代码比较复杂，这种调用关系就会非常隐蔽。在阅读代码的时候，我们就需要仔细查看每个函数的代码实现，才能知道这个类到底依赖了哪些单例类。3. 单例对代码的扩展性不友好

## 3.单例对代码的扩展性不友好 ##

比如一个类在使用的过程中需要有多个实例，拿数据库连接池来举例解释一下。

*线程池设计初期*

*  系统设计初期时，基于系统中数据库统一管理的角度考虑，往往会将数据库连接池设计为单例。

*单例线程池带来的问题*

*  但之后的使用过程中，一旦发现有些sql语句运行得非常慢，这些慢sql长时间占用数据库连接资源，导致影响其他SQL请求无法响应。

*应对慢sql的方案*

*  将sql与其他sql隔离开执行，我们可以在系统中创建两个数据库连接池，慢 SQL 独享一个数据库连接池，其他 SQL 独享另外一个数据库连接池，这样就能避免慢 SQL 影响到其他 SQL 的执行。

*单例线程池对于扩展不友好*

*  如果我们将数据库连接池设计成单例类，显然就无法适应这样的需求变更，也就是说，单例类在某些情况下会影响代码的扩展性、灵活性。所以，数据库连接池、线程池这类的资源池，最好还是不要设计成单例类。实际上，一些开源的数据库连接池、线程池也确实没有设计成单例类。

## 4.单例对代码的可测试性不友好 ##

单例模式的使用会影响到代码的可测试性。

例子

*  单例类依赖较重的外部资源
    
     *  如果单例类依赖比较重的外部资源，比如 DB，我们在写单元测试的时候，希望能通过 mock 的方式将它替换掉。而单例类这种硬编码式的使用方式，导致无法实现 mock 替换。
 *  单例共享变量的同步
    
     *  如果单例类持有成员变量（比如 IdGenerator 中的 id 成员变量），那它实际上相当于一种全局变量，被所有的代码共享。如果这个全局变量是一个可变全局变量，也就是说，它的成员变量是可以被修改的，那我们在编写单元测试的时候，还需要注意不同测试用例之间，修改了单例类中的同一个成员变量的值，从而导致测试结果互相影响的问题。

## 5.单例不支持有参数的构造函数 ##

单例一般都私有化构造，对于有参的构造函数极其不友好。

--------------------

### 例子： ###

比如我们创建一个连接池的单例对象，我们没法通过参数来指定连接池的大小。

#### 解决方案： ####

##### 方案一：先init初始化，后获取实例 #####

public class Singleton {
    
      private static Singleton instance = null;
    
      private final int paramA;
    
      private final int paramB;
    
      private Singleton(int paramA, int paramB) {
    
        this.paramA = paramA;
    
        this.paramB = paramB;
    
      }
    
      public static Singleton getInstance() {
    
        if (instance == null) {
    
           throw new RuntimeException("Run init() first.");
    
        }
    
        return instance;
    
      }
    
      public synchronized static Singleton init(int paramA, int paramB) {
    
        if (instance != null){
    
           throw new RuntimeException("Singleton has been created!");
    
        }
    
        instance = new Singleton(paramA, paramB);
    
        return instance;
    
      }
    
    }
    
    Singleton.init(10, 50); // 先init，再使用
    
    Singleton singleton = Singleton.getInstance();

##### 方案二：将参数放到 getIntance() 方法中 #####

public class Singleton {
    
      private static Singleton instance = null;
    
      private final int paramA;
    
      private final int paramB;
    
      private Singleton(int paramA, int paramB) {
    
        this.paramA = paramA;
    
        this.paramB = paramB;
    
      }
    
      public synchronized static Singleton getInstance(int paramA, int paramB) {
    
        if (instance == null) {
    
          instance = new Singleton(paramA, paramB);
    
        }
    
        return instance;
    
      }
    
    }
    
    Singleton singleton = Singleton.getInstance(10, 50);

但是这么获取实例的方法及其不可取，每次都需要传参，但是只有第一次的参数起作用，对于其他获取实例的地方不友好。

##### 方案三：将参数放到另外一个全局变量中 #####

public class Config {
    
      public static final int PARAM_A = 123;
    
      public static final int PARAM_B = 245;
    
    }
    
    public class Singleton {
    
      private static Singleton instance = null;
    
      private final int paramA;
    
      private final int paramB;
    
      private Singleton() {
    
        this.paramA = Config.PARAM_A;
    
        this.paramB = Config.PARAM_B;
    
      }
    
      public synchronized static Singleton getInstance() {
    
        if (instance == null) {
    
          instance = new Singleton();
    
        }
    
        return instance;
    
      }
    
    }

# 替代单例的方案 #

其实无论是出于对象锁还是对某个资源的唯一代理的目的将类设计成单例都是为了构造一种<font color=red>全局唯一类</font>的目的。

锁这方面当然不用说了，要想让大家获取一把对象锁的方式多得很，单例只是其中的一个解决思路，我们重点来看看某个资源的唯一代理的替代方案。

比如之前说的ID唯一递增生成器可以通过如下几种方式实现：

## 替代方案一：静态方法实现 ##

// 静态方法实现方式
    
    public class IdGenerator {
    
      //通过AtomicLong保证id的原子性
    
      private static AtomicLong id = new AtomicLong(0);
    
      //通过static声明getId，保证全局唯一
    
      public static long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }
    
    // 使用举例
    
    long id = IdGenerator.getId();

但是这种方法会让id属性的初始化不受控制，无法延迟加载，无法做到基于只有使用的时候才初始化该资源的目的。

## 替代方案二：将单例生成的对象当做参数，传递给函数 ##

// 1\. 老的使用方式
    
    public demofunction() {
    
      //...
    
      long id = IdGenerator.getInstance().getId();
    
      //...
    
    }
    
    // 2\. 新的使用方式：依赖注入
    
    public demofunction(IdGenerator idGenerator) {
    
      long id = idGenerator.getId();
    
    }
    
    // 外部调用demofunction()的时候，传入idGenerator
    
    IdGenerator idGenerator = IdGenerator.getInsance();
    
    demofunction(idGenerator);

将单例生成的对象，作为参数传递给函数（也可以通过构造函数传递给类的成员变量），可以解决单例隐藏类之间依赖关系的问题。不过，对于单例存在的其他问题，比如对 OOP 特性、扩展性、可测性不友好等问题，还是无法解决。

## 替代方案总结 ##

实际上，类对象的全局唯一性可以通过多种不同的方式来保证。我们既可以通过单例模式来强制保证，也可以通过工厂模式、IOC 容器（比如 Spring IOC 容器）来保证，还可以通过程序员自己来保证（自己在编写代码的时候自己保证不要创建两个类对象）

# 分布式单例 #

## 如何理解单例模式中的唯一性？ ##

“一个类只允许创建唯一一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。”

定义中提到，“一个类只允许创建唯一一个对象”。那对象的唯一性的作用范围是什么呢？是指线程内只允许创建一个对象，还是指进程内只允许创建一个对象？答案是后者，也就是说，单例模式创建的对象是进程唯一的。

<font color=red>单例类中对象的唯一性的作用范围是进程内的，在进程间是不唯一的</font>。

## 进程唯一和线程唯一的区别 ##

“进程唯一”指的是进程内唯一，进程间不唯一。类比一下，“线程唯一”指的是线程内唯一，线程间可以不唯一。实际上，“进程唯一”还代表了线程内、线程间都唯一，这也是“进程唯一”和“线程唯一”的区别之处。

例子：

假设 IdGenerator 是一个线程唯一的单例类。在线程 A 内，我们可以创建一个单例对象 a。因为线程内唯一，在线程 A 内就不能再创建新的 IdGenerator 对象了，而线程间可以不唯一，所以，在另外一个线程 B 内，我们还可以重新创建一个新的单例对象 b。

public class IdGenerator {
    
      private AtomicLong id = new AtomicLong(0);
    
      private static final ConcurrentHashMap<Long, IdGenerator> instances
    
              = new ConcurrentHashMap<>();
    
      private IdGenerator() {}
    
      public static IdGenerator getInstance() {
    
        Long currentThreadId = Thread.currentThread().getId();
    
        instances.putIfAbsent(currentThreadId, new IdGenerator());
    
        return instances.get(currentThreadId);
    
      }
    
      public long getId() {
    
        return id.incrementAndGet();
    
      }
    
    }

在代码中，我们通过一个 HashMap 来存储对象，其中 key 是线程 ID，value 是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java 语言本身提供了 ThreadLocal 工具类，可以更加轻松地实现线程唯一单例。不过，ThreadLocal 底层实现原理也是基于上面代码中所示的 HashMap。

## 集群单例和线程唯一与进程唯一的关系 ##

“进程唯一”指的是进程内唯一、进程间不唯一。“线程唯一”指的是线程内唯一、线程间不唯一。集群相当于多个进程构成的一个集合，“集群唯一”就相当于是进程内唯一、进程间也唯一。也就是说，不同的进程间共享同一个对象，不能创建同一个类的多个对象。

## 集群唯一实现思路 ##

我们需要把这个单例对象序列化并存储到外部共享存储区（比如文件）。进程在使用这个单例对象的时候，需要先从外部共享存储区中将它读取到内存，并反序列化成对象，然后再使用，使用完成之后还需要再存储回外部共享存储区。

为了保证任何时刻，在进程间都只有一份对象存在，一个进程在获取到对象之后，需要对对象加锁，避免其他进程再将其获取。在进程使用完这个对象之后，还需要显式地将对象从内存中删除，并且释放对对象的加锁。

按照这个思路，作者用伪代码实现了一下这个过程，具体如下所示：

public class IdGenerator {
    
      private AtomicLong id = new AtomicLong(0);
    
      private static IdGenerator instance;
    
      private static SharedObjectStorage storage = FileSharedObjectStorage(/*入参省略，比如文件地址*/);
    
      private static DistributedLock lock = new DistributedLock();
    
      private IdGenerator() {}
    
      public synchronized static IdGenerator getInstance() 
    
        if (instance == null) {
    
          lock.lock();
    
          instance = storage.load(IdGenerator.class);
    
        }
    
        return instance;
    
      }
    
      public synchroinzed void freeInstance() {
    
        storage.save(this, IdGeneator.class);
    
        instance = null; //释放对象
    
        lock.unlock();
    
      }
    
      public long getId() { 
    
        return id.incrementAndGet();
    
      }
    
    }
    
    // IdGenerator使用举例
    
    IdGenerator idGeneator = IdGenerator.getInstance();
    
    long id = idGenerator.getId();
    
    IdGenerator.freeInstance();

# 多例模式 #

单例”指的是，一个类只能创建一个对象。而对应地，“多例”指的就是，一个类可以创建多个对象，但是个数是有限制的，但是多例有两种理解方式：

## 方式一：一个类可以创建多个对象，但是个数是有限制的 ##

比如只能创建 3 个对象。如果用代码来简单示例一下的话，就是下面这个样子：

public class BackendServer {
    
      private long serverNo;
    
      private String serverAddress;
    
      private static final int SERVER_COUNT = 3;
    
      private static final Map<Long, BackendServer> serverInstances = new HashMap<>();
    
      static {
    
        serverInstances.put(1L, new BackendServer(1L, "192.134.22.138:8080"));
    
        serverInstances.put(2L, new BackendServer(2L, "192.134.22.139:8080"));
    
        serverInstances.put(3L, new BackendServer(3L, "192.134.22.140:8080"));
    
      }
    
      private BackendServer(long serverNo, String serverAddress) {
    
        this.serverNo = serverNo;
    
        this.serverAddress = serverAddress;
    
      }
    
      public BackendServer getInstance(long serverNo) {
    
        return serverInstances.get(serverNo);
    
      }
    
      public BackendServer getRandomInstance() {
    
        Random r = new Random();
    
        int no = r.nextInt(SERVER_COUNT)+1;
    
        return serverInstances.get(no);
    
      }
    
    }

## 方式二：同一类型的只能创建一个对象，不同类型的可以创建多个对象。 ##

public class Logger {
    
      private static final ConcurrentHashMap<String, Logger> instances
    
              = new ConcurrentHashMap<>();
    
      private Logger() {}
    
      public static Logger getInstance(String loggerName) {
    
        instances.putIfAbsent(loggerName, new Logger());
    
        return instances.get(loggerName);
    
      }
    
      public void log() {
    
        //...
    
      }
    
    }
    
    //l1==l2, l1!=l3
    
    Logger l1 = Logger.getInstance("User.class");
    
    Logger l2 = Logger.getInstance("User.class");
    
    Logger l3 = Logger.getInstance("Order.class");

在代码中，logger name 就是刚刚说的“类型”，同一个 logger name 获取到的对象实例是相同的，不同的 logger name 获取到的对象实例是不同的。

这种多例模式的理解方式有点类似工厂模式。它跟工厂模式的不同之处是，多例模式创建的对象都是同一个类的对象，而工厂模式创建的是不同子类的对象。

[18721752-a71fc36fe432937c.png]: /images/20210918/f2bf79bee44c457097da461f42fadf7d.png