Part.4 创建型设计模式

设计模式

1、单例模式

1.1 为什么使用单例模式

• 单例设计模式（Singleton Design Pattern）理解起来非常简单。一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。
• 处理场景：
  
  • 处理资源访问冲突。
  • 表示全局唯一类。

1.2 如何实现单例模式

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

1.2.1 饿汉式

• 饿汉式的实现方式比较简单。在类加载的时候，instance静态实例就已经创建并初始化好了，所以，instance实例的创建过程是线程安全的。不过，这样的实现方式不支持延迟加载（在真正用到IdGenerator的时候，再创建实例）

• 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();

  }

  }

1.2.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.2.3 双重检测

• 饿汉式不支持延迟加载，懒汉式有性能问题，不支持高并发。那我们再来看一种既支持延迟加载、又支持高并发的单例实现方式，也就是双重检测实现方式。

• public class IdGenerator {

  private AtomicLong id = new AtomicLong(0);

  private static volatile 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();

  }

  }

1.2.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来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。

1.2.5 枚举

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

• public enum IdGenerator {

  INSTANCE;

  private AtomicLong id = new AtomicLong(0);

  public long getId() {

  return id.incrementAndGet();

  }

  }

1.3 单例存在哪些问题

• 单例这种设计模式对于其中的抽象、继承、多态都支持得不好。
• 会隐藏类之间的依赖关系。单例类不需要显示创建、不需要依赖参数传递，在函数中直接调用就可以了。
• 对代码的扩展性不友好。单例类只能有一个对象实例。如果未来某一天，我们需要在代码中创建两个实例或多个实例，那就要对代码有比较大的改动。
• 对代码的可测试性不友好。单例模式的使用会影响到代码的可测试性。如果单例类依赖比较重的外部资源，比如DB，我们在写单元测试的时候，希望能通过mock的方式将它替换掉。而单例类这种硬编码式的使用方式，导致无法实现mock替换。
• 单例不支持有参数的构造函数。

1.4 替代方法

• 为了保证全局唯一，除了使用单例，我们还可以用静态方法来实现。不过，静态方法这种实现思路，并不能解决我们之前提到的问题。如果要完全解决这些问题，我们可能要从根上，寻找其他方式来实现全局唯一类了。比如，通过工厂模式、IOC容器（比如Spring IOC容器）来保证，由程序员自己来保证（自己在编写代码的时候自己保证不要创建两个类对象）。

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

• 指进程内只允许创建一个对象。
• 那么如何实现线程唯一的单例：通过一个HashMap来存储对象，其中key是线程ID，value是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java语言本身提供了ThreadLocal工具类，可以更加轻松地实现线程唯一单例。不过，ThreadLocal底层实现原理也是基于HashMap。
• 如何实现集群环境下的单例：“集群唯一”就相当于是进程内唯一、进程间也唯一。也就是说，不同的进程间共享同一个对象，不能创建同一个类的多个对象。我们需要把这个单例对象序列化并存储到外部共享存储区（比如文件）。进程在使用这个单例对象的时候，需要先从外部共享存储区中将它读取到内存，并反序列化成对象，然后再使用，使用完成之后还需要再存储回外部共享存储区。为了保证任何时刻在进程间都只有一份对象存在，一个进程在获取到对象之后，需要对对象加锁，避免其他进程再将其获取。在进程使用完这个对象之后，需要显式地将对象从内存中删除，并且释放对对象的加锁。
• 实现一个多列模式：“单例”指的是一个类只能创建一个对象。对应地，“多例”指的就是一个类可以创建多个对象，但是个数是有限制的，比如只能创建3个对象。多例的实现也比较简单，通过一个Map来存储对象类型和对象之间的对应关系，来控制对象的个数。