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.
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:
- Flyweight: class chỉ chứa intrinsic state, bất biến.
- 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.
- 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")
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)
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
256và256là cùng một object còn257thì 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.interncho 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_cachechí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ớimaxsize=Nonenó 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 singletonNone,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ánhIntegerbằ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ênTilemap, mỗi ô chỉ giữ toạ độ. Godot cóTileSettheo 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
DictionaryArraylư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ócategorydtype 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
Treebạ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
- 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
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_cachelà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,tracemallocvà__slots__. Ví dụ trong bài chạy trên CPython 3.11.
- Kai