Pattern 19/22 · Structural
Flyweight Vật thể nhẹ
Chia sẻ phần state trùng nhau giữa nhiều object thay vì mỗi object copy một bản: phần chung nằm trong một object dùng lại theo key, phần riêng (external state) truyền vào lúc dùng.
01 — Mở đầu bằng code đang hỏng
Vấn đề
Game của bạn render một cánh rừng. Ai đó viết class Tree { sprite, hitbox, leafColor, x, y } rồi tạo 100.000 instance, mở heap snapshot và thấy hàng chục MB sprite metadata lặp đi lặp lại. Lọc theo shape, bạn thấy cả 100.000 object chỉ rơi vào 3 tổ hợp sprite/hitbox/leafColor — 99.997 object là bản sao giống hệt nhau, chỉ khác x, y.
Text editor: mỗi ký tự trong file 5MB là một object giữ { fontFamily, fontSize, color, bold, char }. Năm triệu object, và số tổ hợp style thật sự là 12 (body, heading, code, link...). Bạn đang trả tiền RAM cho sự tiện của một constructor.
Web version của cùng bài toán, quen hơn nhiều: bạn render 5.000 dòng table và mỗi dòng tự new Intl.NumberFormat(...) trong function format, hoặc mỗi item JSX nhận một object style inline tạo mới trong render. Formatter là object đắt (nó cache dữ liệu locale bên trong), và bạn dựng 5.000 bản cùng một locale. Object style inline còn tệ theo cách khác: mỗi lần parent render là 5.000 object mới, React không có cách nào skip subtree.
Chi phí không dừng ở RAM. Nó là thời gian allocation, là GC pause khi đống object đó chết, và là phần state chung không sửa tập trung được: đổi sprite của cây loại "oak" nghĩa là phải đi tìm 60.000 object, hoặc phải tin rằng không object nào "tự ý" sửa metadata của cả loài.
Còn một phiên bản âm thầm hơn: bạn tạo new Map(), new RegExp(...), object config literal bên trong một function được gọi 200.000 lần. Code nhìn vô tội, profiler nhìn thấy một cái máy in rác.
02 — Ý tưởng, chưa động vào code
Giải pháp
Tách state làm hai nửa. Intrinsic state: phần chỉ phụ thuộc vào "nó là loại gì" (sprite, hitbox, format pattern, CSS rule) — không đổi theo ngữ cảnh, dùng chung được, và lý tưởng nhất là đóng băng. External state: phần phụ thuộc từng cá thể (x, y, ký tự nào, dòng nào, locale của ai) — nằm ngoài flyweight, truyền vào lúc dùng.
Phần "pattern" còn lại chỉ là một cái Map: flyweight factory. kindOf("oak") gọi 100.000 lần trả về cùng một object (=== thật sự). Toàn bộ sức mạnh nằm ở đó: N entity nhưng chỉ K object, và K nằm trong tay bạn.
Tin tốt: bạn đã dùng flyweight suốt, và bản không class thường đúng hơn. class="row row--paid" là flyweight (một rule, 5.000 node); một Intl.NumberFormat module-scope dùng cho cả danh sách là flyweight; const ROW_STYLE = {...} ngoài component thay vì object inline mỗi render cũng vậy. Flyweight trong JS thường là dời một khai báo ra ngoài vòng lặp, không phải dựng một hệ thống.
03 — Làm thật, mỗi bước một fragment code
Từng bước một
Đo trước: chi phí này là số hay là cảm giác?
Flyweight là tối ưu, nên nó cần chứng cứ. Hai con số bắt buộc phải có: bao nhiêu object bạn đang dựng, và có bao nhiêu tổ hợp giá trị khác nhau thực sự. 200.000 object / 2 tổ hợp là bài toán. 200.000 object / 180.000 tổ hợp là bạn vừa mất thời gian vô ích.
Nếu profiler không chỉ ra allocation này (heap snapshot, performance.measure, flame graph), dừng ở đây. Đừng viết code khó đọc để tiết kiệm một thứ bạn chưa đo.
console.time('build')
const rows = Array.from({ length: 200_000 }, (_, i) => ({
fmt: new Intl.NumberFormat('vi-VN'), // 200k formatter, mỗi cái cache locale data riêng
id: i,
}))
console.timeEnd('build')
// Node: heap đang giữ bao nhiêu? Browser: DevTools > Memory > Heap snapshot.
console.log(Math.round(process.memoryUsage().heapUsed / 1024 / 1024) + ' MB')
// Bao nhiêu flyweight THỰC SỰ cần? Đếm số tổ hợp khác nhau:
console.log(new Set(rows.map(() => 'vi-VN')).size) // 1 -> 200k object cho đúng một thứChẻ state: phần nào là "loại gì", phần nào là "ở đâu"
Liệt kê hết field của object rồi gạch đường. Field chỉ đổi khi loài đổi (sprite của cây sồi, pattern của formatter) thuộc intrinsic. Field đổi theo từng cá thể hoặc theo thời gian (x, health, timestamp) thuộc external.
Chỗ khó của bước này: một field "trông có vẻ chung" nhưng thật ra đổi theo từng người dùng (locale, tenant, theme) không phải intrinsic — nếu bạn nhét nó vào key chia sẻ, key sẽ phình ra đúng bằng số user và flyweight tự giải thể.
class Tree {
// INTRINSIC: chỉ phụ thuộc LOẠI cây -> dùng chung, freeze được
sprite: string // 'oak.png'
hitbox: number // 32
leafColor: string // '#2f6b2f'
// EXTERNAL: phụ thuộc từng cây -> KHÔNG nằm trong flyweight
x: number
y: number
health: number // đổi mỗi frame -> intrinsic được 5 phút trước, giờ thì không
}Dựng flyweight factory: tra key, đóng băng, đừng dựng trùng
Factory là toàn bộ machinery: một Map<key, Flyweight>, miss thì tạo và Object.freeze, hit thì trả về object cũ. Object.freeze không phải trang trí — nó là thứ bảo vệ bạn khỏi bug "một node nào đó sửa metadata dùng chung và làm hỏng 60.000 node khác trong im lặng".
Key nên ngắn và do bạn liệt kê (tên loài, tên style). Đừng serialise cả object làm key: bạn vừa đổi RAM lấy RAM.
class TreeKind {
static allocated = 0
constructor(readonly sprite: string, readonly hitbox: number, readonly color: string) {
TreeKind.allocated++
Object.freeze(this) // dùng chung thì không ai được sửa
}
}
const kinds = new Map<string, TreeKind>()
export function kindOf(name: 'oak' | 'pine'): TreeKind {
let k = kinds.get(name)
if (!k) {
k = name === 'oak'
? new TreeKind('oak.png', 32, '#2f6b2f')
: new TreeKind('pine.png', 16, '#1f4d3a')
kinds.set(name, k)
}
return k
}TreeKind.allocated là biến kiểm chứng: nó phải xấp xỉ số LOÀI, không phải số CÂY.External state đi vào lúc dùng, không nằm trong object
Entity giờ chỉ là một dòng dữ liệu mỏng: key + external state, không giữ metadata. Chỗ nào cần metadata thì tra flyweight ngay tại chỗ dùng. Đây là chỗ quyết định bạn tiết kiệm được 30MB hay 0 đồng.
Cùng một flyweight, hai lần gọi, hai kết quả — không cần object mới. Đó là định nghĩa " hành vi tới từ trạng thái truyền vào".
// Vẽ: metadata lấy từ flyweight, vị trí truyền vào tại chỗ dùng.
// (draw() là method của TreeKind, nhận external state — xem demo bên dưới.)
for (const t of forest)
kindOf(t.name).draw(t.x, t.y)
kindOf('oak').draw(0, 0) // cùng một object
kindOf('oak').draw(999, 999) // ...vẽ ở hai chỗ khác nhausprite, refactor này chưa tiết kiệm được byte nào.Bản web thật: CSS class là flyweight có sẵn của trình duyệt
Một rule CSS được parse, resolve và cache một lần, rồi match vào vô số phần tử. Một class string là key rẻ nhất tồn tại. Inline style là phiên bản flyweight hỏng: mỗi phần tử một declaration riêng, mỗi lần render một object mới.
Đây cũng là lời giải cho JSX/Vue: :class="..." với string constant chia sẻ tốt hơn :style="{...}" với object literal tạo mới mỗi render, vì object mới làm diff luôn khác nhau và phá mất mọi cơ hội skip.
<!-- 5.000 node, MỘT rule: metadata style sống 1 lần -->
<li class="row row--paid">...</li>
<!-- 5.000 node, 5.000 bản declaration, dựng lại mỗi lần parent render -->
<li style="display:flex; padding:8px; color:#16a34a">...</li>
<!-- Trong component: string an toàn, object literal là máy in rác -->
<li :class="ROW_CLASS">
<li :style="{ display: 'flex', padding: '8px' }"> <!-- new object / render / node -->Flyweight mà engine và stdlib làm hộ bạn
Có ba thứ đắt mà người ta hay dựng lại trong vòng lặp: formatter (Intl.NumberFormat, Intl.DateTimeFormat, Intl.Collator), RegExp, và object config. Cả ba đều "dựng một lần, dùng cho cả danh sách" được ngay, bằng một khai báo module-scope hoặc một Map theo key.
RegEx đáng nói riêng: trong JS hiện đại, mỗi lần chạy tới một regex literal bên trong function là một object mới. Đem nó ra ngoài scope là flyweight đúng nghĩa, và thường là fix nhanh nhất trong ba cái.
// ĐẮT: mỗi dòng một formatter, mỗi formatter cache locale data của riêng nó
const bad = (n: number) => new Intl.NumberFormat('vi-VN', { style: 'currency', currency: 'VND' }).format(n)
// RẺ: một instance cho cả danh sách
const vnd = new Intl.NumberFormat('vi-VN', { style: 'currency', currency: 'VND' })
const good = (n: number) => vnd.format(n)
// locale là external state, và số locale là nhỏ -> flyweight factory, như TreeKind
const formatters = new Map<string, Intl.NumberFormat>()
export function money(n: number, locale: string) {
let f = formatters.get(locale)
if (!f) formatters.set(locale, (f = new Intl.NumberFormat(locale)))
return f.format(n)
}
// Regex: hoist ra module scope, mỗi lần chạy literal trong fn là một object mới
const NUMERIC = /^[0-9]+$/String interning: phần đúng, và phần hay bị nói sai
Rất nhiều bài viết lấy dòng đầu của code block dưới (kết quả là true) làm bằng chứng cho "engine intern string". Sai ở chỗ dựa: đặc tả ECMAScript so sánh primitive string theo giá trị, nên kết quả đúng bất kể engine có intern hay không. Interning là chiến lược bên trong, không phải lý do của ===.
Cái thật sự thú vị (và đúng): new String("ab") === new String("ab") là false vì đó là hai object khác nhau — đây chính là chỗ flyweight có ý nghĩa, và nó cũng giải thích tại sao === với object là so sánh tham chiếu. Interning có thật trong engine, nhưng ở nơi bạn không nhìn thấy bằng ===: V8 internalize property key để mọi object dùng chung một tập tên, và các object cùng hình dạng dùng chung một hidden class — nghĩa là 1 triệu object {x, y} chỉ tốn một shape. Flyweight, do engine làm, không API.
'a' + 'b' === 'ab' // true -> primitive so sánh theo GIÁ, không phải bằng chứng intern
new String('ab') === new String('ab') // false -> hai object, hai tham chiếu
// Interning thật nằm ở tầng bạn không đo bằng ===:
// - property key ('sprite', 'hitbox') được internalize -> một bản duy nhất cho cả app
// - object cùng hình dạng dùng chung hidden class/shape -> 1M object, 1 shape
// Hệ quả thực dụng: giữ HÌNH DẠNG object ổn định (cùng thứ tự field, không thêm field
// lúc chạy) để engine chia sẻ shape hộ bạn.=== trên primitive so sánh giá trị; interning là chuyện nội bộ engine. Kể chuyện này đúng, bạn sẽ không bị bắt bài.Kiểm chứng — và biết lúc nào dừng tay
Trước khi tự nhận "đã flyweight", ba assertion: flyweight có thật sự là cùng một object, có bị đóng băng không, và bộ đếm allocation có xấp xỉ số loại không. Thiếu ba cái này, bạn rất dễ viết ra một factory vẫn dựng object mới mỗi lần.
Và điều kiện dừng, thẳng thắn: nếu số key không bị chặn (key sinh từ user id, từ dữ liệu nhập), hoặc nếu flyweight của bạn chứa đúng một con số, thì đừng. Map lookup + key string chưa chắc rẻ hơn một object nhỏ mà V8 dựng bằng pointer bump và dọn bằng scavenger với chi phí gần bằng không.
console.log(kindOf('oak') === kindOf('oak')) // true -> thật sự dùng chung
console.log(Object.isFrozen(kindOf('oak'))) // true -> không ai sửa được
console.log(TreeKind.allocated) // 2 -> không phải 100000
// Dấu hiệu nên dừng / revert:
// - key tới từ dữ liệu user -> Map phình đúng bằng số user
// - flyweight chứa 1 number -> lookup đắt hơn giữ trực tiếp
// - profiler không giảm -> bạn vừa thêm indirection miễn phí04 — Ai nói chuyện với ai
Cấu trúc
- FlyweightPhần intrinsic: metadata của một LOẠI (`TreeKind`: sprite, hitbox, color). Không state riêng, nên `Object.freeze` được.
- FlyweightFactory`Map<key, Flyweight>`: tra key, miss thì tạo + freeze, hit thì trả lại **cùng object**. Chỗ duy nhất được `new`.
- ExternalStatePhần riêng của từng entity: `x`, `y`, `health`, locale. Truyền vào lúc dùng, không bao giờ nằm trong flyweight.
- ClientGiữ N dòng dữ liệu mỏng `{ name, x, y }`, gọi `kindOf(name).draw(x, y)`. Tốn RAM theo K chứ không theo N.
Client: 100.000 entity, mỗi entity chỉ là key + external state
forest[0] = { name: 'oak', x: 0, y: 0 }
forest[1] = { name: 'pine', x: 1, y: 0 }
forest[2] = { name: 'oak', x: 2, y: 0 } intrinsic state (frozen)
... ┌──────────────────────┐
kindOf(name) │ TreeKind 'oak' │
┌───────────────────► Map { ├──────────────────────┤
│ 'oak' -> #1 ─────────┤ TreeKind 'pine' │
└─────────────────── 'pine' -> #2 └──────────────────────┘
}
100.000 lần tra · 2 object · kindOf('oak') === kindOf('oak') -> true05 — Sửa tuỳ ý, chạy ngay tại đây
Chạy thử: 100.000 cây, 2 object thật sự được dựng
// --- Intrinsic state: phần CHUNG, dựng 1 lần cho mỗi loại ---
class TreeKind {
static allocated = 0
constructor(
readonly sprite: string,
readonly hitbox: number,
readonly color: string,
) {
TreeKind.allocated++
Object.freeze(this)
}
// x, y là EXTERNAL state: truyền vào lúc dùng, không nằm trong flyweight
draw(x: number, y: number) {
console.log(this.sprite + ' @' + x + ',' + y + ' hit=' + this.hitbox)
}
}
// --- Flyweight factory: tra key, luôn trả về CÙNG một object ---
const kinds = new Map<string, TreeKind>()
function kindOf(name: 'oak' | 'pine'): TreeKind {
let k = kinds.get(name)
if (!k) {
k = name === 'oak'
? new TreeKind('oak.png', 32, '#2f6b2f')
: new TreeKind('pine.png', 16, '#1f4d3a')
kinds.set(name, k)
}
return k
}
// --- 100k "cây": mỗi cây chỉ là một dòng dữ liệu mỏng ---
const forest: { name: 'oak' | 'pine', x: number, y: number }[] = []
for (let i = 0; i < 100_000; i++)
forest.push({ name: i % 3 === 0 ? 'pine' : 'oak', x: i % 40, y: Math.floor(i / 40) })
for (const t of forest.slice(0, 4))
kindOf(t.name).draw(t.x, t.y)
console.log('cay=' + forest.length + ' TreeKind dựng thật=' + TreeKind.allocated)
console.log('cùng object=' + (kindOf('oak') === kindOf('oak')) + ' frozen=' + Object.isFrozen(kindOf('oak')))pine.png @0,0 hit=16 oak.png @1,0 hit=32 oak.png @2,0 hit=32 pine.png @3,0 hit=16 cay=100000 TreeKind dựng thật=2 cùng object=true frozen=true
Cùng code này chạy được bằng Bun: bun run demo.ts. Output in ra được kiểm tự động trong quá trình build site.
06 — Thành thật về cái giá
Khi nào dùng, khi nào đừng
Dùng khi
- Hàng loạt entity chỉ khác nhau ở vài field ngữ cảnh (vị trí, thứ tự, id), còn lại trùng theo một số ít nhóm.
- Bạn đã đo: heap snapshot hoặc profiler chỉ đúng chỗ allocation này là chi phí, không phải dự đoán.
- Bạn kiểm soát được cách dữ liệu vào tay (sprite atlas, binary buffer, scene graph, document model) nên entity có thể chỉ giữ key.
- Object đắt, tham số ít:
Intl.NumberFormat,Intl.Collator,DateTimeFormat, regex, font face, WebGL buffer — cùng tham số thì dùng lại được. - Cần giới hạn số instance vì lý do tài nguyên (GPU buffer, font đã load, connection) chứ không chỉ vì RAM.
- Có sẵn lớp chia sẻ của nền tảng (CSS rule, hidden class, texture cache) và việc của bạn là đừng phá nó bằng object mới mỗi render.
Đừng dùng khi
- Không đo mà tối ưu. Flyweight đánh đổi readability + một tầng indirection. Nếu số tổ hợp xấp xỉ số object, bạn nhận về đúng một cái Map vô dụng và code khó đọc hơn.
- Dùng chung = mutation lan toả. Một chỗ ghi
kind.hitbox = 64là 60.000 node đổi hình, và bug nằm ở file khác.Object.freeze+ typereadonly, và mọi field có thể đổi theo thời gian phải ra ngoài. - Key không bị chặn là flyweight giả. Key sinh từ user id, tenant id, chuỗi format của người dùng nhập → Map phình đúng bằng số dòng dữ liệu, cộng thêm chi phí hash và lookup.
- Debug nặng. Heap snapshot cho thấy một object được 100.000 nơi tham chiếu; breakpoint "object này của node nào" không còn nghĩa. External state phải đủ để tái dựng ngữ cảnh (log key + toạ độ + frame).
- Trong JS, engine đã làm phần khó. Allocation object nhỏ rất rẻ, GC young-gen gần như miễn phí, property key đã internalize, shape được chia sẻ, style đã gộp theo CSS rule. Flyweight thủ công thắng ở metadata to và instance đắt, thua ở object 3 field.
- Biến nó thành hệ thống. Cache LRU, eviction policy, registry chain cho một bảng 5.000 dòng: đó là over-engineering có tên gọi. Một
constở module scope giải quyết 80% số ca.
07 — Bạn đã gặp nó rồi, chỉ là không gọi tên
Trong code thật
CSS class trong browser
Một rule display:flex; color:#16a34a được parse và resolve một lần, rồi áp cho vô số phần tử; class string là key. Inline style là phiên bản không chia sẻ, và nó chậm hơn theo đúng cơ chế flyweight mô tả.
V8: internalized string và hidden class
Engine internalize property key để mọi object dùng chung một tập tên, và các object cùng hình dạng dùng chung một hidden class (shape). 1 triệu object { x, y } chỉ tốn một shape — flyweight nằm ở compiler, giữ hình dạng object ổn định là cách hưởng lợi.
Intl.NumberFormat / Intl.Collator
Bên trong mỗi instance là dữ liệu locale đã load và cache. Tài liệu và thực hành đều khuyên tạo một instance rồi dùng lại cho nhiều giá trị; nhiều locale thì Map theo locale, tức flyweight factory.
Game engine JS: texture cache và instancing
PixiJS cache texture theo key để hàng nghìn sprite trỏ về cùng một BaseTexture; Three.js có InstancedMesh (một geometry + N ma trận) đẩy việc chia sẻ xuống GPU. Cùng ý tưởng: N entity, K tài nguyên.
08 — Tự tay làm
Bài tập
Một table 5.000 dòng render như sau: trong `renderRow(item, locale)` có `new Intl.NumberFormat(locale, ...)`, có `/^[0-9]+$/.test(item.sku)`, và JSX gán `style={{ display: "flex", padding: 8 }}`. Chỉ ra ba thứ chia sẻ được, sửa lại, và nói rõ bản sửa nhanh/rẻ hơn ở đâu: RAM, CPU hay GC?
Gợi ý, mở từng cái một:
- Mỗi thứ: nó phụ thuộc vào "loại gì" (locale, pattern) hay vào "dòng nào"? Cái thuộc loại trước là intrinsic.
- locale có phải tập nhỏ không? Nếu có, Map<locale, formatter> là flyweight factory; nếu không, bạn đang cache sai chỗ.
- Object style literal trong JSX: ai tạo, tạo bao nhiêu lần, và ai phải dọn?
Formatter + regex là intrinsic (số tổ hợp nhỏ) → module scope hoặc Map theo locale. Object style → thay bằng class string constant. Kết quả: 5.000 formatter + 5.000 regex + 5.000 style object biến thành 1 formatter/locale + 1 regex + 1 class. Rẻ ở cả ba: RAM (bớt instance), CPU (bớt parse/init), và GC (bớt rác trẻ mỗi lần parent render).
// Module scope: dựng MỘT lần cho cả vòng đời trang
const NUMERIC = /^[0-9]+$/
const ROW_CLASS = 'row row--flex'
// intrinsic theo locale (tập locale nhỏ), external là chính giá trị cần format
const formatters = new Map<string, Intl.NumberFormat>()
function nf(locale: string) {
let f = formatters.get(locale)
if (!f) formatters.set(locale, (f = new Intl.NumberFormat(locale, { style: 'currency', currency: 'VND' })))
return f
}
export function renderRow(item: { sku: string, amount: number }, locale: string) {
return {
class: ROW_CLASS, // chia sẻ, không object mới mỗi render
numeric: NUMERIC.test(item.sku),
amount: nf(locale).format(item.amount),
}
}09 — Đọc cặp để hiểu bản chất
Pattern liên quan
- PrototypeCùng trả lời câu hỏi "làm sao có nhiều object giống nhau", nhưng ngược hướng: Prototype **tạo object mới** bằng cách copy, Flyweight cố **không tạo** object mới. Prototype tốn RAM để cô lập, Flyweight tiết kiệm RAM bằng cách chia sẻ.
- CompositeCặp bài trùng trong scene-graph: Composite cho bạn cái cây (100.000 node), Flyweight cho bạn metadata dùng chung giữa các node. Composite mô tả hình dạng, Flyweight mô tả chi phí.
- SingletonFlyweight factory và singleton giống nhau ở "một instance duy nhất". Khác: singleton là tuyên bố về số lượng, flyweight là chiến lược chia sẻ state + external state. Factory của bạn sống như singleton, nhưng đó không phải bản chất của pattern.
- FacadeFacade gom nhiều API thành một API để dễ dùng; flyweight gom nhiều **dữ liệu** thành một bản để rẻ. Cả hai đều là "đừng để mỗi client tự giữ một bản".