对象性能模式¶

概念¶

定义¶

面向对象很好地解决了“抽象”的问题，但是必不可免地要付出一定的代价。
对于通常情况来讲，面向对象的成本大都可以忽略不计；但是某些情况，面向对象所带来的成本必须谨慎处理。

单例模式(Singleton)¶

动机¶

在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保他们的逻辑正确性、以及良好的效率。
如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？
这应该是类设计者的责任，而不是使用者的责任。

模式定义¶

保证一个类仅有一个实例，并提供一个该实例的全局访问点。
特点
- 定义：一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象对象被创建。
- 某个类只能有一个实例；（构造器私有）
- 它必须自行创建这个实例；（自己维护实例化逻辑）
- 它必须自行向整个系统提供这个实例。（对外提供实例化方法）

UML 类图¶

角色¶

单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类

代码¶

/**
 * 第 1 种：懒汉式单例
 * 该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。
 */
class LazySingleton {
  // 保证 instance 在所有线程中同步
  private static instance: LazySingleton = null;
  // private 避免类在外部被实例化
  private constructor() {}

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

/**
 * 第 2 种：饿汉式单例
 * 该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。
 */
class HungrySingleton {
  private static instance: HungrySingleton = new HungrySingleton();
  private constructor() {}

  public static getInstance(): HungrySingleton {
    return this.instance;
  }
}

export default class SingletonClient {
  public static main(args: string[]): void {
    const obj1: LazySingleton = LazySingleton.getInstance();
    const obj2: LazySingleton = LazySingleton.getInstance();
    console.log(obj1 === obj2);

    const obj3: HungrySingleton = HungrySingleton.getInstance();
    const obj4: HungrySingleton = HungrySingleton.getInstance();
    console.log(obj3 === obj4);
  }
}

要点总结¶

Singleton 模式中的实例构造器可以设置为 protected 以允许子类派生。
Singleton 模式一般不要支持拷贝构造函数和 Clone 接口，因为这有可能导致多个对象实例，与 Singleton 模式的初衷违背。
如何实现多线程环境下安全的 Singleton ？注意对双检查锁的正确实现。

享元模式(Flyweight)¶

动机¶

在软件系统采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行代价——主要指内存需求方面的代价。
如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？

模式定义¶

运用共享技术有效地支持大量细粒度的对象。
尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

UML 类图¶

角色¶

抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

代码¶

// 非享元角色
class UnsharedConcreteFlyweight {
  private info: string;

  constructor(info: string) {
    this.info = info;
  }

  public getInfo(): string {
    return this.info;
  }

  public setInfo(info: string): void {
    this.info = info;
  }
}

// 抽象享元角色
interface Flyweight {
  operation(state: UnsharedConcreteFlyweight): void;
}

// 具体享元角色
class ConcreteFlyweight implements Flyweight {
  private key: string;

  constructor(key: string) {
    this.key = key;
    console.log('具体享元' + key + '被创建！');
  }

  public operation(outState: UnsharedConcreteFlyweight): void {
    console.log('具体享元' + this.key + '被调用，');
    console.log('非享元信息是:' + outState.getInfo());
  }
}

// 享元工厂角色
class FlyweightFactory {
  private flyweights: Map<string, Flyweight> = new Map<string, Flyweight>();

  public getFlyweight(key: string): Flyweight {
    let flyweight: Flyweight = this.flyweights.get(key);

    if (flyweight) {
      console.log('具体享元' + key + '已经存在，被成功获取！');
    } else {
      flyweight = new ConcreteFlyweight(key);
      this.flyweights.set(key, flyweight);
    }

    return flyweight;
  }
}

export default class FlyweightPattern {
  public static main(args: string[]): void {
    const factory: FlyweightFactory = new FlyweightFactory();
    const f01: Flyweight = factory.getFlyweight('a');
    const f02: Flyweight = factory.getFlyweight('a');
    const f03: Flyweight = factory.getFlyweight('a');
    const f11: Flyweight = factory.getFlyweight('b');
    const f12: Flyweight = factory.getFlyweight('b');
    f01.operation(new UnsharedConcreteFlyweight('第1次调用a。'));
    f02.operation(new UnsharedConcreteFlyweight('第2次调用a。'));
    f03.operation(new UnsharedConcreteFlyweight('第3次调用a。'));
    f11.operation(new UnsharedConcreteFlyweight('第1次调用b。'));
    f12.operation(new UnsharedConcreteFlyweight('第2次调用b。'));
  }
}

要点总结¶

面向对象很好地解决了抽象性的问题，但是作为一个运行在机器中的程序实体，我们需要考虑对象的代价问题。 Flyweight主要解决面向对象的代价问题，一般不触及面向对象的抽象性问题。
Flyweight采用对象共享的做法来降低系统中对象的个数，从而降低细粒度对象给系统带来的内存压力。在具体实现方面，要注意对象状态的处理。
对象的数量太大从而导致对象内存开销加大——什么样的数量才算大？这需要我们仔细地根据具体应用情况进行评估，而不能凭空臆断。