Trung bình JavaScript

Cleanup trong useEffect của React: xử lý race condition bằng cờ ignore và AbortController

Kết quả search nhảy về query cũ là một race condition trong useEffect. Xử lý response lỗi thời bằng cleanup, cờ ignore, AbortController, và hiểu rõ StrictMode.

16 Th11, 2026 11 phút Cập nhật 23 Th10, 2026 6 Khối code
Sơ đồ
sequenceDiagram participant U as User participant C as Component participant API as Search API U->>C: gõ re C->>API: request A cho re U->>C: gõ react C->>C: cleanup abort A C->>API: request B cho react API-->>C: B trả về trước C->>U: hiện kết quả cho react API-->>C: A trả về trễ C->>C: bỏ qua vì signal đã abort

User gõ "re" vô ô tìm sản phẩm, ngừng một chút, rồi gõ tiếp cho đủ "react". Hai request được gửi đi. Request cho "re" trúng cache lạnh, mất 900 ms; request cho "react" về trong 120 ms. Danh sách hiện kết quả React được một chút, rồi nhảy qua kết quả cho "re" và nằm luôn ở đó. Ô input ghi "react", danh sách thì nói khác, và bug report ghi "search lâu lâu bị random". Không ai tái hiện được trên mạng văn phòng nhanh.

Đó là race condition, và useEffect không có cleanup làm nó thành hành vi mặc định. Effect nào bắt đầu một việc bất đồng bộ cũng cần trả lời một câu: chuyện gì xảy ra nếu việc này xong sau khi component không còn cần nó nữa?

Vì sao response về sau cùng lại thắng

Đây là đoạn code đứng sau cái bug report đó:

function ProductSearch({ query }: { query: string }) {
  const [results, setResults] = useState<string[]>([]);

  useEffect(() => {
    // BUG: no cleanup. Whichever response arrives LAST wins, not the newest query.
    fetch(`/api/search?q=${encodeURIComponent(query)}`)
      .then((res) => res.json())
      .then((data: string[]) => setResults(data));
  }, [query]);

  return <ResultList items={results} />;
}

Mỗi lần query đổi, React chạy lại effect, nhưng không có gì báo cho lần chạy trước biết là nó đã lỗi thời. Cả hai promise rồi cũng resolve, và setResults được gọi theo thứ tự response về, chứ không phải thứ tự request đi. Trên localhost response gần như lúc nào cũng về đúng thứ tự, nên bug này lọt qua code review lẫn QA.

Cùng lỗ hổng đó gây ra lỗi kinh điển còn lại: request resolve sau khi component đã unmount. React 18 đã bỏ cảnh báo "state update on an unmounted component" vì nó chủ yếu gây nhiễu, nhưng request bị phí và mọi side effect trong callback .then thì vẫn là thật.

Cleanup function: bỏ qua kết quả cũ

Function mình return từ effect sẽ chạy trước lần chạy kế tiếp của effect đó và khi component unmount. Vậy nên đó là chỗ để đánh dấu lần chạy trước là đã cũ:

useEffect(() => {
  let ignore = false;

  fetchResults(query).then((data) => {
    if (!ignore) {
      setResults(data);
    }
  });

  return () => {
    ignore = true; // this effect run is stale: the query changed or we unmounted
  };
}, [query]);

Mỗi lần effect chạy có biến ignore riêng nhờ closure. Khi query đổi, React gọi cleanup cũ (set ignore của lần chạy cũ thành true) trước khi bắt đầu lần chạy mới. Response trễ cho "re" vẫn về, nhưng bị bỏ qua. Cách này xài được với mọi API dựa trên promise, kể cả mấy SDK không nhận abort signal.

AbortController: hủy luôn request

Bỏ qua response thì nó vẫn tải về và chiếm connection. Khi API nhận AbortSignal (fetch, axios, đa số SDK hiện đại), abort luôn request:

import { useEffect, useState } from 'react';

type SearchState = { results: string[]; loading: boolean; error: Error | null };

export function useSearch(query: string): SearchState {
  const [state, setState] = useState<SearchState>({ results: [], loading: false, error: null });

  useEffect(() => {
    const controller = new AbortController();
    setState((s) => ({ ...s, loading: true, error: null }));

    fetch(`/api/search?q=${encodeURIComponent(query)}`, { signal: controller.signal })
      .then((res) => {
        if (!res.ok) throw new Error(`HTTP ${res.status}`);
        return res.json() as Promise<string[]>;
      })
      .then((results) => {
        if (!controller.signal.aborted) {
          setState({ results, loading: false, error: null });
        }
      })
      .catch((error: unknown) => {
        if (controller.signal.aborted) return; // superseded or unmounted: not an error
        setState((s) => ({ ...s, loading: false, error: error instanceof Error ? error : new Error(String(error)) }));
      });

    return () => controller.abort();
  }, [query]);

  return state;
}

Luồng chạy giống sơ đồ bên dưới. Có hai chi tiết quan trọng. Thứ nhất, điều kiện kiểm tra controller.signal.aborted chứ không kiểm tra tên lỗi. controller.abort() không có tham số làm fetch reject với một DOMException tên AbortError, nhưng controller.abort(reason) reject với chính cái reason mình truyền vô, nên kiểm tra theo tên sẽ âm thầm hư vào cái ngày có ai đó thêm reason. Thứ hai, kiểm tra này cũng chạy trong .then: abort có thể xảy ra sau khi body đã parse xong, và điều kiện đó giữ cho kết quả lỗi thời không được áp vô state.

Race condition, từng bước một

sequenceDiagram participant U as User participant C as Component participant API as Search API U->>C: gõ re C->>API: request A cho re U->>C: gõ react C->>C: cleanup abort A C->>API: request B cho react API-->>C: B trả về trước C->>U: hiện kết quả cho react API-->>C: A trả về trễ C->>C: bỏ qua vì signal đã abort

Request A bị abort ngay lúc query đổi. Nếu server hay mạng lờ đi lệnh hủy và A vẫn resolve, điều kiện aborted sẽ bỏ nó đi. Hai lớp bảo vệ: abort để tiết kiệm băng thông, điều kiện kiểm tra để bảo đảm đúng.

StrictMode chạy effect hai lần

Ở môi trường development, <StrictMode> mount mọi component, unmount, rồi mount lại. Effect của mình chạy setup, cleanup, setup. Chuyện này là cố ý: nó giả lập tình huống React giữ state qua một lần remount và lôi ra mấy effect không tự dọn dẹp.

// main.tsx: in development StrictMode runs setup -> cleanup -> setup on mount.
createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <App />
  </StrictMode>,
);

// A subscription effect that survives the double run because cleanup undoes setup:
useEffect(() => {
  const socket = connect(roomId);
  socket.on('message', onMessage);
  return () => socket.disconnect();
}, [roomId]);

Nếu thấy hai request trong tab network lúc dev, cái đầu bị abort, thì đó là StrictMode đang làm đúng việc và cleanup của mình đang chạy đúng. Đừng "sửa" bằng một cờ useRef để bỏ qua lần chạy thứ hai. Làm vậy là giấu đi đúng cái bug StrictMode đang chỉ ra, và mấy tính năng production có remount component sẽ dính nó sau này. Bản build production chạy effect một lần mỗi lần mount.

Quy tắc StrictMode muốn ép mình theo: từ góc nhìn của user, setup rồi cleanup rồi setup phải y hệt như chỉ setup một lần. Subscription thì disconnect, timer thì clear, request thì abort hoặc bị bỏ qua.

Kiểm thử race condition

Race condition khó tái hiện bằng tay, nên mình điều khiển thời gian trong test. Cho fetch mock trả về deferred promise, resolve chúng sai thứ tự, rồi assert trên state cuối cùng. Vitest với renderHook của React Testing Library giữ test ngắn gọn:

import { act, renderHook, waitFor } from '@testing-library/react';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { useSearch } from './useSearch';

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((r) => { resolve = r; });
  return { promise, resolve };
}

describe('useSearch', () => {
  afterEach(() => vi.restoreAllMocks());

  it('ignores a slow response that arrives after a newer one', async () => {
    const slow = deferred<Response>();
    const fast = deferred<Response>();
    const fetchMock = vi.spyOn(globalThis, 'fetch')
      .mockReturnValueOnce(slow.promise)
      .mockReturnValueOnce(fast.promise);

    const { result, rerender } = renderHook(({ q }) => useSearch(q), { initialProps: { q: 're' } });
    rerender({ q: 'react' });

    await act(async () => fast.resolve(Response.json(['react', 'react-dom'])));
    await waitFor(() => expect(result.current.results).toEqual(['react', 'react-dom']));

    await act(async () => slow.resolve(Response.json(['re', 'redux'])));
    expect(result.current.results).toEqual(['react', 'react-dom']);

    const firstSignal = fetchMock.mock.calls[0][1]?.signal;
    expect(firstSignal?.aborted).toBe(true);
  });

  it('aborts the in-flight request on unmount', () => {
    const fetchMock = vi.spyOn(globalThis, 'fetch').mockReturnValue(new Promise(() => {}));
    const { unmount } = renderHook(() => useSearch('vue'));

    unmount();

    expect(fetchMock.mock.calls[0][1]?.signal?.aborted).toBe(true);
  });
});

Test đầu tiên chính là bug report được viết thành code: response chậm cho "re" resolve sau cùng và không được ghi đè "react". Nó cũng kiểm tra signal của request đầu đã bị abort, chứng minh cleanup có chạy. Test thứ hai lo phần unmount. Không test nào phụ thuộc timer thật hay mạng, nên chạy mất vài mili giây và không bao giờ chập chờn.

Những lỗi hay gặp

Effect function là async. useEffect(async () => { ... }) trả về promise chứ không phải cleanup function, nên React không có gì để gọi. Khai báo một async function bên trong effect rồi gọi nó, giữ nguyên return () => ... đồng bộ.

Coi AbortError là lỗi. Hiện toast báo lỗi cho request bị abort là màn hình sẽ chớp "Có lỗi xảy ra" mỗi lần user gõ nhanh. Kiểm tra signal.aborted rồi return êm.

Xài chung một controller cho nhiều lần chạy. Controller cất trong useRef rồi xài lại sẽ bị abort một lần, sau đó mọi request về sau fail ngay lập tức. Tạo controller mới cho mỗi lần effect chạy.

Thiếu dependency. Nếu effect đọc query mà dependency array là [], effect không bao giờ chạy lại, và cleanup cũng chẳng bảo vệ được gì. Để lint rule react-hooks/exhaustive-deps làm việc của nó.

Cleanup không đối xứng với setup. Thêm listener bằng một function reference rồi gỡ bằng một arrow function inline mới thì chẳng gỡ được gì. Giữ lại reference và truyền đúng cái đó cho cả hai lời gọi.

Khi nào nên xài effect, khi nào không

Effect dành cho việc đồng bộ với thứ gì đó bên ngoài React: mạng, WebSocket, API của trình duyệt, widget bên thứ ba. Xài nó khi component phải giữ đồng bộ với một hệ thống bên ngoài suốt thời gian nó nằm trên màn hình.

Đừng xài effect để tính data từ props hay state, hoặc để phản ứng với sự kiện của user:

// Avoid: derived state through an effect (extra render, can go stale)
const [visible, setVisible] = useState<Todo[]>([]);
useEffect(() => setVisible(todos.filter((t) => !t.done)), [todos]);

// Prefer: compute during render (wrap in useMemo only if it is expensive)
const visibleTodos = todos.filter((t) => !t.done);

// Avoid: effect reacting to a flag set by a click
// Prefer: do the work in the event handler that caused it
async function handleSubmit(form: FormValues) {
  await saveOrder(form);
  toast.success('Order saved');
}

Giá trị tính ra được thì đặt trong render. Việc do một cú click gây ra thì nằm trong click handler, nơi mình biết chính xác vì sao nó chạy. Với data fetching vượt quá vài trường hợp đơn giản, một thư viện như TanStack Query hoặc tầng data của framework (React Server Components, route loader) lo luôn race condition, cache, gộp request trùng và retry, và thường là lựa chọn tốt hơn so với fetch effect tự viết. Còn khi tự viết, cho nó một cleanup làm lần chạy trước trở nên vô hại. Chỉ một thói quen đó thôi là dẹp được cả một nhóm bug "random".

Thử thách tương tác

Thử thách

Luyện tập ngay điều vừa học. Viết lời giải, mở gợi ý nếu bí.

Đề bài

Viết class LatestRequest bảo đảm chỉ request mới nhất được tính, giống cleanup của effect. begin() abort ticket đang active (nếu có) rồi trả về số ticket mới: lần đầu là 1, sau đó 2, 3 và cứ vậy, không bao giờ xài lại. Abort một ticket là chạy mọi callback đã đăng ký cho nó đúng một lần, theo thứ tự đăng ký. isCurrent(ticket) bên JavaScript / is_current(ticket) bên Python chỉ trả true cho ticket đang active. onAbort(ticket, callback) / on_abort(ticket, callback) lưu callback lại khi ticket đang active, và gọi nó ngay khi ticket không còn active (đã bị thay hoặc đã dispose). dispose() abort ticket đang active để không còn ticket nào là current; gọi thêm lần nữa thì không làm gì, và begin() vẫn chạy tiếp được với số kế tiếp.

Code khởi tạo

javascript
class LatestRequest {
  constructor() {
    this.counter = 0;
    this.active = null;    // ticket number of the current request, or null
    this.callbacks = [];   // abort callbacks registered for the active ticket
  }

  begin() {
    // TODO: abort the active ticket (run its callbacks once, in order)
    // TODO: return a new ticket number (1, 2, 3, ...) and make it active
    throw new Error('TODO');
  }

  isCurrent(ticket) {
    // TODO: true only for the active ticket
    throw new Error('TODO');
  }

  onAbort(ticket, callback) {
    // TODO: store the callback for the active ticket, call it right away for any other ticket
    throw new Error('TODO');
  }

  dispose() {
    // TODO: abort the active ticket; afterwards no ticket is current
    throw new Error('TODO');
  }
}
python
from typing import Callable


class LatestRequest:
    def __init__(self) -> None:
        self.counter = 0
        self.active: int | None = None  # ticket number of the current request
        self.callbacks: list[Callable[[], None]] = []  # abort callbacks of the active ticket

    def begin(self) -> int:
        # TODO: abort the active ticket (run its callbacks once, in order)
        # TODO: return a new ticket number (1, 2, 3, ...) and make it active
        raise NotImplementedError

    def is_current(self, ticket: int) -> bool:
        # TODO: True only for the active ticket
        raise NotImplementedError

    def on_abort(self, ticket: int, callback: Callable[[], None]) -> None:
        # TODO: store the callback for the active ticket, call it right away for any other ticket
        raise NotImplementedError

    def dispose(self) -> None:
        # TODO: abort the active ticket; afterwards no ticket is current
        raise NotImplementedError

Lời giải của bạn

Gợi ý

Đã mở hết gợi ý
Gợi ý 1

Chỉ cần giữ số ticket đang active và các callback của ticket đó; ticket cũ không cần lưu gì

Gợi ý 2

Đổi danh sách callback thành danh sách rỗng trước khi chạy, để mỗi callback chạy đúng một lần

Gợi ý 3

begin() và dispose() xài chung bước 'abort ticket đang active', gom nó vô một helper

Lời giải · javascript
class LatestRequest {
  constructor() {
    this.counter = 0;
    this.active = null;    // ticket number of the current request, or null
    this.callbacks = [];   // abort callbacks registered for the active ticket
  }

  begin() {
    this.abortActive();
    this.counter += 1;
    this.active = this.counter;
    return this.active;
  }

  isCurrent(ticket) {
    return this.active !== null && ticket === this.active;
  }

  onAbort(ticket, callback) {
    if (this.isCurrent(ticket)) {
      this.callbacks.push(callback);
    } else {
      callback();
    }
  }

  dispose() {
    this.abortActive();
  }

  abortActive() {
    const callbacks = this.callbacks;
    this.callbacks = [];
    this.active = null;
    for (const cb of callbacks) cb();
  }
}
Lời giải · python
from typing import Callable


class LatestRequest:
    def __init__(self) -> None:
        self.counter = 0
        self.active: int | None = None  # ticket number of the current request
        self.callbacks: list[Callable[[], None]] = []  # abort callbacks of the active ticket

    def begin(self) -> int:
        self._abort_active()
        self.counter += 1
        self.active = self.counter
        return self.active

    def is_current(self, ticket: int) -> bool:
        return self.active is not None and ticket == self.active

    def on_abort(self, ticket: int, callback: Callable[[], None]) -> None:
        if self.is_current(ticket):
            self.callbacks.append(callback)
        else:
            callback()

    def dispose(self) -> None:
        self._abort_active()

    def _abort_active(self) -> None:
        callbacks, self.callbacks = self.callbacks, []
        self.active = None
        for cb in callbacks:
            cb()

Cùng chủ đề JavaScript