Mẫu Flyweight (Design Pattern) giải thích kèm ví dụ

Mục đích và vấn đề mà mẫu này giải quyết

Mục đích: dùng chia sẻ để hỗ trợ hiệu quả số lượng lớn các đối tượng nhỏ, chi tiết. Mẫu này đến từ sách Gang of Four (GoF) và thuộc nhóm cấu trúc.

Hãy tưởng tượng một bản đồ vẽ một triệu cây. Mỗi cây có vị trí (x, y) và một loại: tên loài, màu sắc và ảnh texture vài kilobyte. Nếu mỗi đối tượng cây giữ bản sao texture riêng, bộ nhớ tăng theo số cây và chương trình có thể hết bộ nhớ. Nhưng chỉ có vài loài. Texture, tên và màu giống nhau ở mọi cây sồi.

Flyweight chuyển dữ liệu lặp lại vào một số ít đối tượng dùng chung. Khi đó mỗi cây chỉ lưu vị trí của nó cùng một tham chiếu đến loại cây dùng chung. Một triệu cây với năm loài chỉ cần năm bản texture thay vì một triệu.

Trạng thái nội tại và ngoại tại

Bước then chốt là tách dữ liệu của mỗi đối tượng thành hai loại:

Vì flyweight được chia sẻ nên nó phải bất biến. Nếu một client có thể đổi màu của loại sồi dùng chung, mọi cây sồi trên bản đồ sẽ đổi theo.

Cấu trúc và các thành phần

Cài đặt bằng TypeScript

Factory dùng một Map với khóa là các giá trị nội tại. TreeType là flyweight, Tree là context, và Forest là client.

class TreeType {
  constructor(
    readonly name: string,
    readonly color: string,
    readonly texture: Uint8Array, // large, shared data
  ) {}
  draw(x: number, y: number): string {
    return this.name + " (" + this.color + ") at " + x + "," + y;
  }
}
class TreeTypeFactory {
  private static cache = new Map<string, TreeType>();
  static get(name: string, color: string): TreeType {
    const key = name + "|" + color;
    let type = this.cache.get(key);
    if (!type) {
      type = new TreeType(name, color, new Uint8Array(4096));
      this.cache.set(key, type);
    }
    return type;
  }
}
class Tree {
  constructor(readonly x: number, readonly y: number, readonly type: TreeType) {}
  draw(): string {
    return this.type.draw(this.x, this.y);
  }
}
const forest: Tree[] = [];
for (let i = 0; i < 100_000; i++) {
  const [name, color] = i % 2 === 0 ? ["Oak", "green"] : ["Birch", "white"];
  forest.push(new Tree(i, i * 2, TreeTypeFactory.get(name, color)));
}
const types = new Set(forest.map((t) => t.type));
console.log(forest.length, "trees,", types.size, "tree types");
console.log(forest[3].draw());
// 100000 trees, 2 tree types
// Birch (white) at 3,6

Không có factory, chương trình sẽ cấp phát 100.000 bộ đệm texture. Có factory, chỉ có hai. Các đối tượng Tree vẫn tồn tại, nhưng mỗi đối tượng chỉ giữ hai số và một tham chiếu.

Khi nào nên dùng và khi nào không

Dùng Flyweight khi tất cả điều sau đều đúng:

• Chương trình tạo ra một số lượng rất lớn đối tượng tương tự.
• Mức dùng bộ nhớ là vấn đề đã được đo đạc, không phải phỏng đoán.
• Phần lớn trạng thái của mỗi đối tượng có thể được biến thành ngoại tại hoặc dùng chung.
• Chương trình không phụ thuộc vào danh tính đối tượng (hai context dùng cùng flyweight được phép chia sẻ nó).

Tránh dùng khi số đối tượng nhỏ, khi các đối tượng cần thay đổi dữ liệu dùng chung một cách độc lập, hoặc khi độ phức tạp tăng thêm do phải truyền trạng thái ngoại tại khiến mã khó đọc hơn lượng bộ nhớ tiết kiệm được. Nhiều khi có cách đơn giản hơn: lưu dữ liệu trong các mảng song song hoặc typed array, hoặc intern các chuỗi lặp trong một Map.

Đánh đổi: Flyweight đổi bộ nhớ lấy thời gian CPU. Trạng thái ngoại tại có thể phải tính lại hoặc tra cứu mỗi lần gọi phương thức.

Ứng dụng thực tế

• Java: Integer.valueOf(int) trả về các đối tượng Integer được lưu đệm cho giá trị từ -128 đến 127, nên việc boxing số nhỏ không cấp phát đối tượng mới mỗi lần.
• Java: String.intern() trả về bản sao chuẩn dùng chung của một chuỗi từ string pool.
• Trình soạn thảo văn bản và trình duyệt kết xuất glyph từ bộ nhớ đệm phông chữ dùng chung: mỗi ký tự trên màn hình lưu vị trí của nó, còn hình dạng glyph chỉ lưu một lần cho mỗi phông và cỡ chữ.
• Game engine dùng instanced rendering: một mesh và một material được dùng chung, và chỉ dữ liệu theo từng thể hiện như vị trí và góc quay được gửi cho mỗi bản sao.

Các mẫu liên quan