React từ cơ bản đến nâng cao
Trang chủ / Module 16
🧬 Module 16 / 22 · 6 ngày 📅 Tuần 9 ●●●● Cực khó

React chạy bên trong: render, reconciliation, Fiber và lanes

Hai pha render và commit, thuật toán reconciliation, cấu trúc Fiber và double buffering, cách hooks được lưu, lanes và độ ưu tiên, bailout, batching và StrictMode.

ReconciliationFiberLanesCommit phase
📌 Vì sao module này quan trọng

Đây là phần mà phỏng vấn senior React luôn đào: "điều gì khiến một component render lại?", "vì sao React cần key?", "Fiber giải quyết vấn đề gì?". Quan trọng hơn, hiểu cơ chế này giúp bạn tự suy ra đúng hành vi của mọi API khác — thay vì học thuộc từng quy tắc.

🎯 Mục tiêu học tập

  • Mô tả trigger → render → commit và việc gì diễn ra ở mỗi pha
  • Liệt kê chính xác 4 lý do một component render lại
  • Giải thích hai giả định của thuật toán reconciliation và hệ quả
  • Mô tả Fiber node, cây current/work-in-progress và vì sao render có thể bị ngắt
  • Giải thích hooks được lưu trên fiber thế nào và vì sao thứ tự gọi hook phải cố định
  • Hiểu lanes (độ ưu tiên) và bailout ở mức đủ để debug

Ba bước: trigger, render, commit

  1. Trigger: lần đầu (root.render) hoặc có cập nhật state (setState, dispatch, context đổi, store ngoài báo đổi).
  2. Render: React gọi hàm component để lấy cây element mới và so với cây cũ (reconciliation). Pha này phải thuần, không chạm DOM, có thể bị tạm dừng, làm lại hoặc bỏ đi.
  3. Commit: áp các thay đổi tối thiểu lên DOM (đồng bộ, không ngắt được), gắn ref, chạy useLayoutEffect; sau khi trình duyệt vẽ thì chạy useEffect.
setState ──► schedule update (gán lane) ──► RENDER PHASE (có thể ngắt)
                                              beginWork: gọi component, diff children
                                              completeWork: chuẩn bị DOM node, gom effect
                                            ──► COMMIT PHASE (đồng bộ)
                                              before mutation → mutation (sửa DOM)
                                              → layout (ref, useLayoutEffect)
                                            ──► trình duyệt vẽ ──► passive effects (useEffect)
Render ≠ cập nhật DOM

Một component có thể render (hàm được gọi) mà DOM không đổi gì vì kết quả giống lần trước. Render thừa tốn CPU, nhưng không phải lúc nào cũng là vấn đề — đo trước khi tối ưu (Module 17).

Một component render lại khi nào

  1. State của chính nó đổi (giá trị mới khác giá trị cũ theo Object.is).
  2. Component cha render lại — mặc định toàn bộ con cháu cũng render lại, dù props không đổi.
  3. Context mà nó đọc (useContext/use) đổi value.
  4. Store ngoài mà nó subscribe (useSyncExternalStore) báo snapshot mới.

"Props đổi" không nằm trong danh sách: props đổi chỉ xảy ra vì cha render lại. Ngược lại, cha render lại là con render lại — trừ khi con được bọc memo và props bằng nhau nông, hoặc element con được tạo ở chỗ khác và truyền vào (children — tham chiếu element giữ nguyên nên React bailout).

function Parent() {
  const [n, setN] = useState(0);
  return (
    <>
      <button onClick={() => setN(n + 1)}>{n}</button>
      <ExpensiveTree />            {/* render lại mỗi lần bấm */}
    </>
  );
}

function ParentBetter({ children }) {   // <ParentBetter><ExpensiveTree/></ParentBetter>
  const [n, setN] = useState(0);
  return <><button onClick={() => setN(n + 1)}>{n}</button>{children}</>;  // children KHÔNG render lại
}

Gọi setState với đúng giá trị hiện tại: React thường bỏ qua (bailout), dù đôi khi vẫn gọi lại component đó một lần trước khi bỏ — không ảnh hưởng con.

Reconciliation: diff hai cây trong O(n)

So sánh tổng quát hai cây là O(n³). React dùng hai giả định để đưa về O(n):

  1. Khác type → cây con khác hoàn toàn. <div> đổi thành <section>, hoặc <UserCard> đổi thành <AdminCard>: React huỷ cả cây cũ (unmount, mất state) và tạo mới. Đây là lý do khai báo component bên trong component làm mất state: mỗi lần render type là hàm mới.
  2. Danh sách con được nhận diện bằng key. Không có key, React so theo vị trí.
// type giống nhau ở cùng vị trí -> giữ DOM và state, chỉ cập nhật thuộc tính
<input className={dark ? 'dark' : 'light'} />

// Hai nhánh khác type ở cùng vị trí -> unmount/mount
{isEditing ? <input /> : <span>{text}</span>}

Với danh sách, React duyệt mảng mới: key khớp thì tái sử dụng fiber (kể cả khi đổi vị trí — chỉ di chuyển DOM node), key mới thì tạo, key biến mất thì xoá. Bằng chứng bạn hiểu: giải thích được vì sao index làm key gây lỗi khi xoá phần tử đầu (Module 4).

Fiber: đơn vị công việc có thể ngắt

Trước React 16, reconciler đệ quy trên call stack: đã bắt đầu render cây 10.000 node là phải làm xong, trang đơ. Fiber biến mỗi component thành một object (một "đơn vị công việc") liên kết với nhau bằng con trỏ, để React tự duyệt bằng vòng lặp — dừng được, tiếp tục được, bỏ được.

// Rút gọn các trường quan trọng của một Fiber
interface Fiber {
  type: any;               // hàm component, class, hoặc 'div'
  key: string | null;
  stateNode: any;          // DOM node / instance
  child: Fiber | null;     // con đầu tiên
  sibling: Fiber | null;   // anh em kế tiếp
  return: Fiber | null;    // cha
  pendingProps: any;
  memoizedProps: any;      // props của lần render trước
  memoizedState: any;      // với function component: danh sách liên kết các hook
  updateQueue: any;        // effect, cập nhật chờ
  lanes: number;           // công việc đang chờ ở fiber này (độ ưu tiên)
  childLanes: number;      // công việc đang chờ ở cây con
  flags: number;           // Placement, Update, Deletion, Passive...
  alternate: Fiber | null; // bản sao ở cây còn lại
}
  • Double buffering: có hai cây — current (đang hiển thị) và workInProgress (đang dựng). Mỗi fiber trỏ tới bản kia qua alternate. Render xong, commit chỉ cần đổi con trỏ root sang cây mới. Nếu bị ngắt, cây đang dựng bị bỏ, màn hình vẫn nhất quán.
  • Work loop: performUnitOfWork đi xuống bằng child, hết con thì completeWork và sang sibling, hết anh em thì về return. Ở chế độ concurrent, sau mỗi đơn vị React hỏi scheduler "còn thời gian không?" (khoảng 5ms một lát) — nếu có việc ưu tiên hơn (người dùng gõ phím), nó nhường main thread.
  • Bailout: nếu fiber không có công việc (lanes trống), props/context không đổi, React bỏ qua; nếu cả childLanes trống thì bỏ qua luôn cả cây con. Đây là cơ chế làm memo và mẫu children hiệu quả.

Hooks được lưu ở đâu

memoizedState của fiber là danh sách liên kết các hook theo thứ tự gọi. Lần render đầu, mỗi lời gọi useState tạo một node mới; các lần sau, React đi dọc danh sách theo đúng thứ tự để lấy state tương ứng.

fiber.memoizedState ─► [useState: count] ─► [useEffect: deps,cb] ─► [useMemo: value,deps] ─► null
function Bad({ isAdmin }) {
  const [a] = useState(1);
  if (isAdmin) useEffect(() => {});   // ❌ lần sau isAdmin=false -> hook thứ 3 nhận nhầm node của hook thứ 2
  const [b] = useState(2);
}

Mỗi useState có một update queue vòng. setState không đổi giá trị ngay mà thêm một update (kèm lane) vào queue và lên lịch render; lần render sau, React xử lý lần lượt các update trong queue. Đây là lý do updater function c => c + 1 cộng dồn đúng, còn count + 1 thì không (Module 3).

Lanes: độ ưu tiên của cập nhật

Mỗi cập nhật được gán một lane (một bit trong bitmask) theo nguồn gốc:

LaneNguồnHành vi
SyncLaneSự kiện rời rạc: click, keydown, inputRender ngay, không ngắt
InputContinuousSự kiện liên tục: scroll, mousemoveƯu tiên cao
DefaultsetState trong setTimeout, fetch xongBình thường
Transition lanesstartTransition, useDeferredValue, form actionNgắt được, có thể bị bỏ để làm lại
Idle / Offscreen<Activity mode="hidden">, việc nềnLàm khi rảnh

Bitmask cho phép React gom (batch) các cập nhật cùng lane vào một lần render, và khi một cập nhật khẩn cấp tới giữa lúc đang render transition, React bỏ dở công việc transition, làm việc khẩn trước, rồi render lại transition trên state mới nhất. Bạn không gọi lane trực tiếp — bạn chọn lane qua API: event handler thường, startTransition, useDeferredValue (Module 18).

Batching, flushSync và StrictMode

import { flushSync } from 'react-dom';

function addAndScroll(todo) {
  flushSync(() => setTodos(t => [...t, todo]));   // ép commit ngay, đồng bộ
  listRef.current.lastElementChild.scrollIntoView(); // DOM đã có phần tử mới
}
  • Automatic batching (React 18+): mọi cập nhật trong cùng một tick được gộp. flushSync là lối thoát hiếm khi cần (đo/scroll DOM ngay sau khi thêm phần tử), nó làm chậm nên đừng lạm dụng.
  • StrictMode ở dev: gọi hàm component, initializer của useState/useMemo, reducer hai lần để phát hiện code không thuần; mount → unmount → mount để kiểm tra cleanup của effect và ref callback. Không ảnh hưởng production.

🚩 Sai lầm hay gặp

  • Nghĩ 'props đổi làm component render lại' — thực chất là cha render lại.
  • Tối ưu render mà không đo; nhiều render nhỏ hoàn toàn rẻ.
  • Cho rằng render phase chạy đúng một lần — trong concurrent mode nó có thể chạy nhiều lần trước khi commit.

🏋️ Bài tập thực hành

Tự viết mini-React

Theo bài "Build your own React" (pomb.us), tự viết createElement, render có work loop dùng requestIdleCallback, fiber với child/sibling/return, reconciliation có key, và useState. Viết README giải thích bằng lời: vì sao cần hai cây, vì sao thứ tự hook phải cố định. Sau đó dùng React DevTools Profiler trên app thật, ghi lại 'Why did this render?' cho 5 component.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Tôi vẽ được sơ đồ trigger → render → commit → passive effects
  • Tôi kể đúng 4 lý do component render lại và giải thích mẫu children tránh render
  • Tôi giải thích được hai giả định của reconciliation
  • Tôi giải thích được Fiber, double buffering và vì sao render ngắt được
  • Tôi giải thích được vì sao thứ tự hook phải cố định bằng cấu trúc dữ liệu
  • Tôi biết lane là gì và API nào tạo transition lane