Khi nào và làm sao dùng worker threads?

Question

Accepted Answer

**Worker threads** cho phép Node chạy JavaScript trên **các luồng riêng biệt** với song song thực sự — giải quyết hạn chế lớn nhất của Node: công việc nặng CPU chặn luồng chính đơn (và do đó mọi request). Dùng chúng cho tính toán nặng, không phải cho I/O (mà event loop đã xử lý hiệu quả).

## Vấn đề chúng giải quyết

```js
// ❌ công việc nặng CPU này CHẶN event loop → mọi request đóng băng trong suốt thời gian đó
app.get("/hash", (req, res) => {
  const result = expensiveComputation(); // vd crypto nặng, xử lý ảnh
  res.json(result); // trong khi đó, không request nào khác được xử lý
});
```

Node chạy JS của bạn trên một luồng. Một phép tính đồng bộ dài chặn **mọi thứ** — event loop không thể xử lý request khác cho tới khi nó xong. Worker threads chuyển công việc đó ra khỏi luồng chính.

## Dùng một worker thread

```js
// main.js
import { Worker } from "worker_threads";

// luồng chính vẫn rảnh để xử lý request khác trong khi cái này chạy
const result = await runHeavyTask({ numbers: [...] });
```

```js
// worker.js — chạy song song, trên luồng riêng
import { workerData, parentPort } from "worker_threads";

const result = expensiveComputation(workerData); // không chặn luồng chính
parentPort.postMessage(result);                    // gửi kết quả về
```

Worker chạy độc lập; luồng chính tiếp tục phục vụ request và nhận kết quả qua một message khi xong.

## Khi nào nên dùng (và không)

```text
✓ DÙNG cho công việc nặng CPU: xử lý ảnh/video, mã hóa, nén,
  parse dữ liệu lớn, tính toán phức tạp, suy luận ML
✗ ĐỪNG dùng cho I/O (DB, file, HTTP) — event loop bất đồng bộ đã xử lý
  việc đó hiệu quả; worker sẽ thêm chi phí mà không lợi ích
```

Quy tắc: **worker cho nặng-CPU, event loop cho nặng-I/O.**

## Worker threads vs child_process vs cluster

```text
worker_threads → chia sẻ bộ nhớ (truyền dữ liệu hiệu quả), luồng trong tiến trình — công việc CPU
child_process  → tiến trình OS riêng, chạy chương trình khác — cô lập nặng hơn
cluster        → fork cả server qua các CPU — mở rộng xử lý request
```

## Tại sao điều này quan trọng

Worker threads giải quyết điểm yếu cốt lõi của Node — tác vụ nặng CPU chặn event loop đơn luồng và đóng băng mọi request đồng thời.

Biết đẩy tính toán nặng sang một worker (giữ luồng chính phản hồi nhanh), và quan trọng là **khi nào** dùng chúng (chỉ cho nặng-CPU, không bao giờ cho I/O), là điều giúp một service Node xử lý được công việc nặng thỉnh thoảng mà không hy sinh khả năng đồng thời vốn làm Node có giá trị.

Để gộp worker trong production, các thư viện như Piscina quản lý một thread pool hiệu quả.