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

Concurrent React: transitions, Suspense, use() và Error Boundary

Cập nhật khẩn cấp và không khẩn cấp, useTransition, useDeferredValue, Suspense cho code và dữ liệu, use() với Promise, Error Boundary, Activity và View Transitions.

useTransitionuseDeferredValueSuspenseuse()
📌 Vì sao module này quan trọng

Concurrent rendering là thay đổi lớn nhất của React kể từ hooks và là nền tảng của Server Components, streaming SSR, form actions. Đây cũng là phần khó nhất để hiểu đúng: Suspense không phải chỉ là loading spinner, và transition không làm code chạy nhanh hơn — nó thay đổi thứ tự ưu tiên.

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

  • Phân biệt cập nhật khẩn cấp và transition, dùng useTransition đúng chỗ
  • Dùng useDeferredValue cho giá trị đến từ props
  • Giải thích cơ chế Suspense: component 'ném' Promise, React hiển thị fallback gần nhất
  • Dùng use() đọc Promise và Context, hiểu vì sao Promise phải được cache
  • Đặt Suspense và Error Boundary theo chủ đích để thiết kế trạng thái tải
  • Biết <Activity> và View Transitions

Khẩn cấp và không khẩn cấp

Người dùng gõ vào ô tìm kiếm: chữ hiện trong ô phải ngay lập tức (khẩn cấp); danh sách 5.000 kết quả có thể chậm vài trăm ms (không khẩn cấp). Không có concurrent, cả hai cùng render đồng bộ → ô input lag.

function Search() {
  const [text, setText] = useState('');       // khẩn cấp
  const [query, setQuery] = useState('');     // không khẩn cấp
  const [isPending, startTransition] = useTransition();

  function onChange(e) {
    setText(e.target.value);
    startTransition(() => setQuery(e.target.value));   // render này ngắt được
  }
  return (
    <>
      <input value={text} onChange={onChange} />
      <div style={{ opacity: isPending ? 0.6 : 1 }}><Results query={query} /></div>
    </>
  );
}

Khi người dùng gõ tiếp giữa lúc đang render kết quả, React bỏ dở lần render cũ và làm lại với giá trị mới nhất. Không phải debounce: không có độ trễ cố định, máy nhanh thì gần như tức thời.

  • Không dùng transition cho state điều khiển input (setText) — input sẽ không phản hồi.
  • Từ React 19, hàm trong startTransition có thể async ("Actions"): isPending đúng suốt thời gian chờ request; nhưng các setState sau await phải bọc lại trong startTransition thì mới là transition.
  • Transition chỉ có lợi khi render là nút thắt. Nếu chậm vì mạng hay vì một tính toán đồng bộ 2 giây trong một hàm, nó không giúp gì (cần Worker).

useDeferredValue

function SearchPage({ query }) {                 // query đến từ props, không có quyền gọi startTransition
  const deferredQuery = useDeferredValue(query);
  const isStale = query !== deferredQuery;
  return (
    <div style={{ opacity: isStale ? 0.5 : 1 }}>
      <SlowList query={deferredQuery} />        {/* SlowList nên được memo để bỏ qua render khẩn cấp */}
    </div>
  );
}

React render hai lần: lần khẩn với giá trị cũ của deferredQuery (SlowList memo → bailout, rất nhanh), rồi render nền với giá trị mới. useDeferredValue(value, initialValue) cho phép hiển thị giá trị khởi tạo nhẹ ở lần đầu.

Suspense hoạt động thế nào

Khi một component trong lúc render cần thứ chưa sẵn sàng (code của lazy, dữ liệu qua use(promise) hoặc thư viện hỗ trợ Suspense), nó tạm dừng (về mặt kỹ thuật: ném ra Promise). React tìm <Suspense> gần nhất phía trên, hiển thị fallback, và render lại khi Promise xong.

<Suspense fallback={<PageSkeleton />}>
  <Header />
  <Suspense fallback={<FeedSkeleton />}>
    <Feed />                              {/* tạm dừng riêng, Header vẫn hiển thị */}
  </Suspense>
  <Suspense fallback={<SidebarSkeleton />}>
    <Sidebar />
  </Suspense>
</Suspense>
  • Suspense boundary là công cụ thiết kế trạng thái tải: mọi thứ trong cùng boundary hiện cùng lúc; boundary lồng nhau cho phép hiện dần (progressive reveal).
  • Nếu nội dung đã hiển thị và một cập nhật làm nó tạm dừng lại, React sẽ thay nội dung bằng fallback — trừ khi cập nhật đó là transition: khi đó React giữ giao diện cũ và chờ (vì vậy chuyển trang trong router dùng transition để không nháy skeleton).
  • React 19 kích hoạt fallback ngay khi một con tạm dừng (không render tiếp các anh em trước), rồi "pre-warm" các anh em sau — tránh waterfall khi các con tự fetch.
  • Trên server (streaming SSR, RSC), mỗi Suspense boundary là một điểm stream: HTML của fallback gửi trước, nội dung gửi sau khi xong. Đây là nền móng của Next.js App Router.

use(): đọc Promise và Context

import { use, Suspense } from 'react';

function Comments({ commentsPromise }) {
  const comments = use(commentsPromise);     // tạm dừng tới khi Promise resolve; reject -> Error Boundary
  return comments.map(c => <p key={c.id}>{c.text}</p>);
}

function Post({ id }) {
  // Promise phải ổn định qua các lần render: tạo ở cha / ngoài render / lấy từ cache
  const commentsPromise = useMemo(() => fetchComments(id), [id]);
  return (
    <Suspense fallback={<p>Đang tải bình luận…</p>}>
      <Comments commentsPromise={commentsPromise} />
    </Suspense>
  );
}

function Theme({ show }) {
  if (show) {
    const theme = use(ThemeContext);         // use() được gọi trong điều kiện — khác các hook khác
    return <p>{theme}</p>;
  }
  return null;
}
⚠️ Không tạo Promise mới trong component đang bị tạm dừng

use(fetch(...)) trực tiếp trong render: mỗi lần render lại tạo Promise mới → tạm dừng mãi mãi. Trong client component, Promise nên đến từ thư viện có cache (TanStack Query useSuspenseQuery, router loader) hoặc từ Server Component truyền xuống. useMemo ở ví dụ trên chỉ là minh hoạ: memo có thể bị bỏ khi component bị tạm dừng lúc mount, nên dự án thật nên dùng cache bên ngoài.

Error Boundary

Lỗi ném ra khi render (hoặc Promise bị reject trong use) làm unmount toàn bộ cây nếu không có Error Boundary. Error Boundary vẫn phải là class component — thực tế dùng thư viện react-error-boundary.

import { ErrorBoundary } from 'react-error-boundary';
import { QueryErrorResetBoundary } from '@tanstack/react-query';

<QueryErrorResetBoundary>
  {({ reset }) => (
    <ErrorBoundary
      onReset={reset}
      fallbackRender={({ error, resetErrorBoundary }) => (
        <div role="alert"><p>Lỗi: {error.message}</p><button onClick={resetErrorBoundary}>Thử lại</button></div>
      )}>
      <Suspense fallback={<Skeleton />}><ProductDetail id={id} /></Suspense>
    </ErrorBoundary>
  )}
</QueryErrorResetBoundary>

Error Boundary không bắt lỗi trong event handler, code async ngoài render, setTimeout — những lỗi đó tự try/catch. React 19 thêm onCaughtError/onUncaughtError trên createRoot để gửi log tập trung (Sentry).

Activity và View Transitions

import { Activity } from 'react';   // React 19.2

<Activity mode={tab === 'chat' ? 'visible' : 'hidden'}>
  <ChatPanel />   {/* ẩn nhưng giữ state (chữ đang gõ, vị trí cuộn); effect bị dọn khi ẩn, render nền ưu tiên thấp */}
</Activity>

<Activity> thay cho mẫu display:none thủ công hoặc mất state khi unmount; còn dùng để render trước màn hình người dùng sắp mở. <ViewTransition> (đang ở kênh thử nghiệm/canary tại thời điểm viết) gắn hiệu ứng chuyển cảnh của trình duyệt vào transition của React — kiểm tra trạng thái trên react.dev trước khi dùng.

🚩 Sai lầm hay gặp

  • Bọc setState của input vào startTransition.
  • Tạo Promise mới mỗi render rồi truyền vào use() → treo vô hạn.
  • Một <Suspense> duy nhất bọc cả app → cả trang nháy thành skeleton mỗi khi một phần tải.
  • Nghĩ Error Boundary bắt được lỗi trong onClick.

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

Dashboard tải dần

Dashboard 4 widget gọi API độ trễ khác nhau (300ms-3s). Dùng useSuspenseQuery + Suspense lồng nhau để hiện dần, Error Boundary riêng từng widget có nút thử lại (giả lập lỗi 30%). Thêm ô tìm kiếm lọc 5.000 dòng bằng useTransition và so sánh với debounce. Đổi tab bằng <Activity> để giữ state.

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

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

  • Tôi giải thích được transition khác debounce thế nào
  • Tôi giải thích được Suspense bằng cơ chế 'tạm dừng và tìm boundary gần nhất'
  • Tôi biết vì sao transition giữ UI cũ thay vì hiện fallback
  • Tôi dùng use() đúng cách với Promise được cache
  • Tôi đặt được Suspense + Error Boundary theo thiết kế trạng thái tải