👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Flyweight Pattern: chia sẻ trạng thái chung để tiết kiệm bộ nhớ

TL;DR: Flyweight (đối tượng hạng nhẹ) giải quyết bài toán "có quá nhiều object nhỏ giống nhau ăn hết RAM". Cách làm: tách phần trạng thái chung và bất biến (intrinsic state) ra một đối tượng dùng chung duy nhất, giữ lại phần riêng của từng chỗ dùng (extrinsic state) ở object gọi, rồi truyền vào lúc cần. Một factory có cache đảm bảo mỗi giá trị intrinsic chỉ tồn tại đúng một bản. Trong ví dụ đo thật bên dưới, 50.000 cây trên bản đồ giảm từ 32,47 MB xuống 5,38 MB. Đây là một tối ưu bộ nhớ, chỉ dùng khi bạn đã đo và thấy vấn đề.

Bạn viết một game 2D. Bản đồ có 50.000 cái cây. Mỗi cây là một object giữ toạ độ, tên loài, màu lá và dữ liệu lưới hình học (mesh) để vẽ. Code chạy đúng, nhưng process ngốn vài trăm MB và máy yếu thì giật.

Nhìn kỹ sẽ thấy một sự lãng phí lộ liễu: bản đồ chỉ có 3 loài cây, nhưng dữ liệu của 3 loài đó đang được nhân bản 50.000 lần. Toạ độ thì đúng là mỗi cây một khác. Còn mesh và màu lá của cây thông thì cây thông nào cũng y hệt nhau. Flyweight chính là cái tên GoF đặt cho việc dọn chỗ lãng phí này.

Flyweight là gì

Flyweight là một mẫu thuộc nhóm Structural (cấu trúc) của Gang of Four. Định nghĩa gốc: dùng cơ chế chia sẻ (sharing) để hỗ trợ một số lượng rất lớn các đối tượng nhỏ (fine-grained objects) một cách hiệu quả.

Mấu chốt của toàn bộ pattern nằm ở một phép tách. Bạn chia trạng thái của đối tượng làm hai loại:

  • Intrinsic state (trạng thái nội tại): phần không phụ thuộc vào ngữ cảnh dùng nó. Cây thông nào cũng có cùng mesh, cùng tên loài, cùng màu lá. Phần này giống nhau ở mọi chỗ nên chia sẻ được, và vì chia sẻ nên bắt buộc phải bất biến (immutable). Đây chính là thứ được lưu trong flyweight.
  • Extrinsic state (trạng thái ngoại lai): phần riêng của từng chỗ dùng. Cây này ở toạ độ (12, 40), cây kia ở (300, 7). Phần này khác nhau ở mọi chỗ nên không chia sẻ được. Nó nằm ở object gọi, hoặc được truyền vào flyweight lúc gọi method.

Analogy dễ hình dung nhất là bộ font chữ. Một trang văn bản có hàng nghìn chữ "a". Trình soạn thảo không lưu hàng nghìn bản vẽ hình dạng chữ "a". Nó lưu đúng một glyph "a" (các đường cong, độ rộng, chiều cao: intrinsic), rồi với mỗi chữ "a" trên trang chỉ lưu vị trí, cỡ chữ và màu (extrinsic). Lúc vẽ, nó đưa vị trí và màu vào cho cái glyph dùng chung đó tự vẽ ra. Một glyph, hàng nghìn lần xuất hiện.

Đọc flyweight theo nghĩa quyền anh: "hạng ruồi", hạng cân nhẹ nhất. Tên pattern nói về việc làm cho từng đối tượng nhẹ đi, chứ không phải về tốc độ.

Vấn đề khi không có Flyweight

Khi mỗi object tự giữ một bản sao của phần dữ liệu chung, chi phí bộ nhớ tăng tuyến tính theo số object, dù lượng thông tin thực sự khác nhau lại rất nhỏ. Với 50.000 cây và 3 loài, bạn đang trả tiền cho 50.000 bản mesh trong khi chỉ cần 3.

Hậu quả không chỉ là RAM. Nhiều object hơn nghĩa là garbage collector phải quét nhiều hơn, cache của CPU bị đá ra liên tục, và ở ngôn ngữ như Python thì mỗi object còn cõng thêm phần header cố định. Bài toán này xuất hiện bất cứ khi nào bạn có số lượng rất lớn đối tượng nhỏ mà độ đa dạng thực tế lại thấp: hạt particle, ô gạch (tile) trên map, ký tự trong trình soạn thảo, dòng log đã parse, node trong cây cú pháp.

Cách hoạt động

Ba mảnh ghép:

  1. Flyweight: class chỉ chứa intrinsic state, bất biến.
  2. Factory: một hàm có cache, nhận khoá là bộ giá trị intrinsic. Cùng khoá thì trả về cùng một instance, không tạo mới.
  3. Context: object nhẹ chứa extrinsic state, giữ một tham chiếu tới flyweight.

Dưới đây là bản đo thật. Tôi dựng cùng một khu rừng 50.000 cây theo hai cách, và dùng tracemalloc để lấy mức bộ nhớ đỉnh (peak) của từng cách.

import random, tracemalloc

N = 50_000
KINDS = [("Thong", "xanh dam"), ("Bach duong", "xanh nhat"), ("Soi", "nau")]

def load_mesh(name):                 # gia lap du lieu nang: luoi hinh hoc cua loai cay
    return tuple(float(i) for i in range(16))

# --- Cach 1: moi cay tu giu mot ban sao cua du lieu chung ---
class TreeNaive:
    __slots__ = ("x", "y", "name", "color", "mesh")
    def __init__(self, x, y, name, color):
        self.x, self.y = x, y
        self.name, self.color = name, color
        self.mesh = load_mesh(name)  # ban sao rieng cho tung cay

# --- Cach 2: Flyweight ---
class TreeType:                      # INTRINSIC: dung chung, bat bien
    __slots__ = ("name", "color", "mesh")
    def __init__(self, name, color):
        self.name, self.color = name, color
        self.mesh = load_mesh(name)

_pool = {}
def tree_type(name, color):          # factory: cung khoa -> cung mot instance
    key = (name, color)
    if key not in _pool:
        _pool[key] = TreeType(name, color)
    return _pool[key]

class Tree:                          # EXTRINSIC: rieng tung cay
    __slots__ = ("x", "y", "kind")
    def __init__(self, x, y, kind):
        self.x, self.y, self.kind = x, y, kind

def peak_of(build):
    tracemalloc.start()
    forest = build()
    peak = tracemalloc.get_traced_memory()[1]
    tracemalloc.stop()
    del forest
    return peak / 1024 / 1024

random.seed(7)
mb_naive = peak_of(lambda: [TreeNaive(random.random(), random.random(), *random.choice(KINDS))
                            for _ in range(N)])
random.seed(7)
mb_fly = peak_of(lambda: [Tree(random.random(), random.random(), tree_type(*random.choice(KINDS)))
                          for _ in range(N)])

print(f"So cay tren ban do      : {N}")
print(f"Khong Flyweight         : {mb_naive:6.2f} MB, {N} ban sao du lieu chung")
print(f"Co Flyweight            : {mb_fly:6.2f} MB, {len(_pool)} ban sao du lieu chung")
print(f"Giam                    : {(1 - mb_fly / mb_naive) * 100:.1f}% bo nho")
So cay tren ban do : 50000 Khong Flyweight : 32.47 MB, 50000 ban sao du lieu chung Co Flyweight : 5.38 MB, 3 ban sao du lieu chung Giam : 83.4% bo nho

Số cây không đổi: vẫn đúng 50.000 object Tree, mỗi cây vẫn có toạ độ riêng. Thứ giảm là số bản sao của phần dữ liệu chung: từ 50.000 xuống 3. Phần 5,38 MB còn lại chủ yếu là bản thân 50.000 object Tree và cái list chứa chúng, đó là chi phí không tránh được vì mỗi cây thật sự cần một chỗ đứng riêng.

Chú ý cách factory được viết: nó là lối vào duy nhất để lấy một TreeType. Nếu chỗ nào đó trong code gọi thẳng TreeType("Thong", "xanh dam"), bạn lại đẻ ra bản sao mới và mất sạch lợi ích. Đây là lý do Flyweight gần như luôn đi kèm một factory, và thường giấu constructor đi.

Python đã làm chuyện này sẵn cho bạn

Tinh thần Flyweight có sẵn trong runtime của CPython, và trong thư viện chuẩn có công cụ để bạn viết factory chỉ bằng một dòng:

import sys
from functools import lru_cache

# 1. CPython cache san so nguyen nho: mot Flyweight co san trong runtime
a, b = int("256"), int("256")
c, d = int("257"), int("257")
print("256 dung chung object :", a is b)
print("257 dung chung object :", c is d)

# 2. Chuoi tao luc chay thi khong tu dong dung chung, tru khi intern
s1 = "".join(["fly", "weight"])
s2 = "".join(["fly", "weight"])
print("chuoi bang nhau       :", s1 == s2, "| cung object:", s1 is s2)
print("sau sys.intern        :", sys.intern(s1) is sys.intern(s2))

# 3. lru_cache lam factory Flyweight chi trong mot dong
@lru_cache(maxsize=None)
def tree_type(name, color):
    print(f"  [tao moi] TreeType({name})")
    return (name, color, tuple(range(4)))

tree_type("Thong", "xanh dam")
tree_type("Thong", "xanh dam")
tree_type("Soi", "nau")
print("so instance thuc su   :", tree_type.cache_info().currsize)
256 dung chung object : True 257 dung chung object : False chuoi bang nhau : True | cung object: False sau sys.intern : True [tao moi] TreeType(Thong) [tao moi] TreeType(Soi) so instance thuc su : 2

Ba thứ đáng nhớ ở đây:

  • Small integer cache: CPython tạo sẵn và dùng chung các số nguyên trong khoảng -5 đến 256. Đó là lý do 256 và 256 là cùng một object còn 257 thì không. Một Flyweight pool có sẵn trong interpreter.
  • String interning: các chuỗi giống định danh (identifier) trong mã nguồn được intern tự động, nhưng chuỗi ghép lúc chạy thì không. sys.intern cho bạn ép chúng về một bản duy nhất. Rất đáng dùng khi bạn parse hàng triệu bản ghi có tập khoá lặp lại, ví dụ tên cột hay tên tag.
  • functools.lru_cache chính là một factory Flyweight. Gọi hai lần với cùng tham số chỉ tạo object một lần. Với maxsize=None nó không bao giờ loại bỏ mục nào, đúng hành vi của một pool cố định.

Thêm một người bạn của Flyweight trong Python: __slots__. Nó bỏ cái __dict__ mặc định của mỗi instance, cắt đáng kể chi phí cố định trên từng object. Khi bạn có hàng trăm nghìn object nhỏ thì Flyweight lo phần dữ liệu chung, còn __slots__ lo phần vỏ của từng object. Hai thứ này rất hay đi cùng nhau, như trong ví dụ trên.

Trong hệ thống thật

Flyweight ít khi được gọi đúng tên trong code production, nhưng nó có mặt ở những chỗ rất quen:

  • String interning của CPython: bảng intern toàn cục trong Objects/unicodeobject.c, cộng với small integer cache và các singleton None, True, False. Đây là Flyweight ở tầng runtime, bạn hưởng lợi mà không phải viết gì.
  • java.lang.Integer.valueOf: trả về instance dùng chung cho các giá trị trong khoảng -128 đến 127. Đây là lý do kinh điển khiến so sánh Integer bằng == trong Java đúng với số nhỏ và sai với số lớn.
  • Glyph trong trình soạn thảo và engine dựng chữ: chính ví dụ mà GoF dùng để giới thiệu pattern, lấy từ trình soạn thảo Lexi. Ngày nay FreeType và các glyph atlas trong game engine vẫn làm y hệt: nạp một bitmap cho mỗi glyph rồi vẽ lại nó ở nghìn vị trí khác nhau.
  • Tile và entity trong game: Unity dùng TileBase (một asset dùng chung) đặt ở vô số ô trên Tilemap, mỗi ô chỉ giữ toạ độ. Godot có TileSet theo cùng ý tưởng. Mesh và material cũng được chia sẻ giữa các instance theo đúng kiểu này.
  • Metadata trong data engine: Apache Arrow có kiểu DictionaryArray lưu tập giá trị riêng biệt một lần rồi để các dòng trỏ về bằng chỉ số, và pandas có category dtype làm y hệt. Parquet gọi nó là dictionary encoding. Đây là Flyweight áp dụng cho dữ liệu dạng cột.
  • Đối tượng cấu hình và metadata dùng chung: bảng mô tả schema, compiled regex trong cache của module re, driver metadata của một kết nối database. Những thứ này được tạo một lần rồi chia sẻ cho mọi request, thay vì dựng lại cho từng lời gọi.

Điểm chung: tất cả đều là dữ liệu chỉ đọc, được tra cứu qua một điểm vào duy nhất, và được dùng lại ở số lượng rất lớn.

Trade-off

Được:

  • Giảm bộ nhớ rất mạnh khi số đối tượng lớn mà độ đa dạng thấp. Ví dụ ở trên giảm 83,4%, và tỉ lệ này càng tốt khi số object càng tăng.
  • Giảm số object sống, kéo theo áp lực lên garbage collector nhẹ đi.
  • Khởi tạo nhanh hơn nếu dữ liệu intrinsic đắt (nạp file, parse, biên dịch regex): làm một lần thay vì N lần.
  • Cache locality tốt hơn, vì phần dữ liệu nóng dùng chung nằm gọn một chỗ.
  • Có sẵn một điểm tập trung để tra cứu và kiểm soát, ví dụ đếm xem hệ thống thực sự có bao nhiêu biến thể.

Phải trả giá:

  • Code phức tạp hơn. Một class tự nhiên tách làm hai, cộng thêm một factory và một cache cần bảo trì.
  • Bắt buộc bất biến. Sửa một flyweight là sửa mọi chỗ đang dùng nó. Đây là loại bug khó chịu nhất mà pattern này mang lại.
  • Mỗi lần lấy object phải tra cứu, tốn một chút CPU và một lần băm khoá. Bạn đổi CPU lấy RAM.
  • Khó debug hơn. Nhìn vào một Tree bạn không thấy đủ trạng thái của nó nữa, phải lần theo tham chiếu.
  • Cache là trạng thái toàn cục. Nó có thể giữ object sống mãi (rò rỉ bộ nhớ nếu khoá không giới hạn) và cần khoá nếu nhiều thread cùng tạo flyweight.
  • Mã đọc kém tự nhiên hơn: extrinsic state phải truyền vào ở từng lời gọi, danh sách tham số dài ra.

Khi nào KHÔNG nên dùng

Đây là một tối ưu, không phải một thiết kế mặc định. Chỉ áp dụng Flyweight khi bạn đã đo và thấy bộ nhớ thực sự là vấn đề. Dùng phòng xa là đúng nghĩa over-engineering: bạn nhận hết chi phí phức tạp mà chưa chắc nhận được lợi ích nào.
  • Số object không lớn. Vài trăm hay vài nghìn object thì tiết kiệm được vài chục KB, không đáng đánh đổi.
  • Độ đa dạng cao. Nếu gần như mỗi object có một giá trị intrinsic khác nhau, cache sẽ to bằng đúng số object, và bạn còn tốn thêm chi phí của cái dict. Flyweight chỉ thắng khi tỉ lệ số object trên số giá trị riêng biệt là rất lớn.
  • Trạng thái cần thay đổi. Nếu phần bạn định chia sẻ lại phải sửa theo từng chỗ dùng, thì nó là extrinsic chứ không phải intrinsic. Ép nó thành flyweight là tự đặt bẫy.
  • Vòng đời ngắn. Object tạo rồi bỏ ngay không tích tụ bộ nhớ, còn cache thì sống mãi.

Cái bẫy đắt nhất đáng được nhìn tận mắt. Đây là chuyện xảy ra khi flyweight không bất biến:

class TreeType:
    def __init__(self, name, color):
        self.name, self.color = name, color

pool = {}
def tree_type(name, color):
    return pool.setdefault((name, color), TreeType(name, color))

cay_a = tree_type("Thong", "xanh dam")
cay_b = tree_type("Thong", "xanh dam")   # cung mot object voi cay_a

cay_a.color = "vang"                     # doi mau cho DUY NHAT mot cay... theo y dinh
print("cay_b.color =", cay_b.color)      # nhung ca rung doi theo
cay_b.color = vang

Bạn định đổi màu một cây, kết quả là cả rừng đổi màu. Không exception, không log, chỉ có một lỗi hiển thị lạ ở chỗ khác hoàn toàn. Cách phòng: dùng frozen dataclass, NamedTuple, hoặc ít nhất là __slots__ cộng với quy ước rõ ràng rằng class này chỉ đọc.

Tóm tắt

  • Flyweight chia sẻ một bản duy nhất của phần trạng thái chung giữa rất nhiều đối tượng, thay vì để mỗi đối tượng giữ một bản sao.
  • Phép tách cốt lõi: intrinsic (chung, bất biến, nằm trong flyweight) và extrinsic (riêng từng chỗ dùng, truyền vào lúc gọi).
  • Một factory có cache là lối vào duy nhất, đảm bảo cùng khoá thì cùng instance. functools.lru_cache làm việc này trong một dòng.
  • Đo thật: 50.000 cây giảm từ 32,47 MB xuống 5,38 MB, số bản sao dữ liệu chung từ 50.000 xuống 3.
  • Python đã có sẵn tinh thần này: small integer cache, string interning, sys.intern. Kết hợp với __slots__ để cắt luôn chi phí vỏ object.
  • Bắt buộc bất biến: sửa một flyweight là sửa mọi nơi dùng nó.
  • Chỉ dùng khi đã đo thấy vấn đề bộ nhớ, và khi số object lớn mà độ đa dạng thấp.

Nguồn tham khảo

  • Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - Flyweight thuộc nhóm Structural, định nghĩa "use sharing to support large numbers of fine-grained objects efficiently"; ví dụ minh hoạ trong sách là glyph của trình soạn thảo văn bản.
  • Tài liệu Python: sys.intern, functools.lru_cache, tracemalloc và __slots__. Ví dụ trong bài chạy trên CPython 3.11.
Series Design Patterns - nhóm Structural. Flyweight là mẫu Structural nói về cách chia sẻ đối tượng để giữ cấu trúc nhẹ. Nó hay bị nhầm với Proxy: Proxy kiểm soát truy cập tới một đối tượng, còn Flyweight chia sẻ một đối tượng cho nhiều chỗ dùng. Cái factory ở đây cũng cùng họ với Factory Method: giấu việc tạo object sau một lối vào duy nhất. Nền tảng nên đọc trước: Program to interface & Composition over inheritance. Và nhớ đọc Over-engineering trước khi áp dụng, vì đây là pattern dễ bị dùng sớm nhất. Xem toàn bộ lộ trình ở mục lục Design Patterns.

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét