设计模式-享元模式

简介

享元模式（Flyweight Pattern）是一种用于效率和内存优化的结构型设计模式。这种模式通过共享尽可能多的相似对象来减少内存使用，特别适合于处理大量对象时，每个对象都消耗大量内存的场景。

享元模式的核心思想

享元模式的核心在于分离变与不变。它将对象信息分为两个部分：

• 内部状态（Intrinsic State）：不依赖于场景，且不会改变的数据。
• 外部状态（Extrinsic State）：依赖于场景，并且会改变的数据。

内部状态存储在享元对象内部，通常不会改变，而外部状态则可以从外部传入享元对象来改变其行为。通过这种方式，可以使用相对较少的共享对象来替代大量的对象。

使用场景

• 大量相似对象的创建需要消耗大量的内存。
• 对象的大多数状态都可以外部化，可以被多个对象共享。
• 应用程序不依赖于对象标识。由于享元对象可以被共享，因此对于标识敏感的应用，享元模式可能不适用。

示例实现

假设我们正在开发一个游戏，其中有成千上万的树木。每棵树都有其位置、形状和颜色等属性。其中，形状和颜色是内部状态，因为它们在多个树之间可以共享。位置是外部状态，每棵树的位置都是独特的。

• 首先定义树的享元对象：

  // 享元对象
  class TreeType {
      constructor(name, color, texture) {
          this.name = name;
          this.color = color;
          this.texture = texture;
      }
  
      display(location) {
          console.log(`Displaying a ${this.color} ${this.name} at ${location.x}, ${location.y}`);
      }
  }
  
  // 享元工厂
  class TreeFactory {
      static treeTypes = new Map();
  
      static getTreeType(name, color, texture) {
          const key = `${name}_${color}_${texture}`;
          if (!this.treeTypes.has(key)) {
              this.treeTypes.set(key, new TreeType(name, color, texture));
              console.log('Creating a new TreeType object');
          }
          return this.treeTypes.get(key);
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26

  然后是管理树木的类，它使用享元对象：

  class Tree {
      constructor(x, y, treeType) {
          this.x = x;
          this.y = y;
          this.treeType = treeType;
      }
  
      display() {
          this.treeType.display({ x: this.x, y: this.y });
      }
  }
  
  class Forest {
      constructor() {
          this.trees = [];
      }
  
      plantTree(x, y, name, color, texture) {
          const type = TreeFactory.getTreeType(name, color, texture);
          const tree = new Tree(x, y, type);
          this.trees.push(tree);
      }
  
      displayForest() {
          this.trees.forEach(tree => tree.display());
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27

  使用这些类：

  const forest = new Forest();
  forest.plantTree(1, 2, 'Maple', 'Red', 'Smooth');
  forest.plantTree(5, 3, 'Maple', 'Red', 'Smooth');
  forest.plantTree(8, 2, 'Oak', 'Green', 'Rough');
  forest.displayForest();
  1
  2
  3
  4
  5

优点

• 内存节省：享元模式可以极大地减少程序所需的对象数量，从而降低内存消耗。
• 提高性能：减少实例化对象的数量减轻了内存的压力，提高了应用性能。

缺点

• 复杂度增加：需要区分内部状态和外部状态，管理共享对象，增加了实现的复杂度。
• 线程安全问题：在多线程环境下，若共享对象的内部状态被外部状态改变，可能会导致线程安全问题。

总结

总的来说，享元模式在处理大量相似对象时提供了一种有效的内存优化策略。然而，它的使用应当谨慎，需要正确评估和设计内部状态和外部状态，以确保不会对应用程序的逻辑造成负面影响。在 JavaScript 等动态语言中，享元模式可以帮助管理内存消耗，尤其是在客户端浏览器环境中，这对提升用户体验和应用性能都是非常有益的。