คุณใช้ worker threads เมื่อใดและอย่างไร

Question

Accepted Answer

**Worker threads** ให้ Node รัน JavaScript บน **separate threads** ด้วย true parallelism — แก้ไขข้อจำกัดที่ใหญ่ที่สุดของ Node: CPU-intensive work ทำให้ single main thread (และจึงทำให้ requests ทั้งหมด) bBlock ใช้สำหรับการคำนวณหนัก ไม่ใช่ I/O (ซึ่ง event loop จัดการอย่างมีประสิทธิภาพแล้ว)।

## ปัญหาที่พวกเขาแก้ไข

```js
// ❌ this CPU-heavy work BLOCKS the event loop → all requests freeze for its duration
app.get("/hash", (req, res) => {
  const result = expensiveComputation(); // e.g. heavy crypto, image processing
  res.json(result); // meanwhile, no other request can be handled
});
```

Node รัน JS ของคุณบนหนึ่ง thread การคำนวณแบบ synchronous ที่ยาวนาน **ปิดกั้นทุกอย่าง** — event loop ไม่สามารถประมวลผล requests อื่นๆ จนกว่าจะเสร็จ Worker threads ย้ายงานนั้นออกจาก main thread

## ใช้ worker thread

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

// the main thread stays free to handle other requests while this runs
const result = await runHeavyTask({ numbers: [...] });
```

```js
// worker.js — runs in parallel, on its own thread
import { workerData, parentPort } from "worker_threads";

const result = expensiveComputation(workerData); // doesn't block the main thread
parentPort.postMessage(result);                    // send the result back
```

Worker ทำงานอย่างอิสระ main thread ยังคงให้บริการ requests และได้รับผลลัพธ์ผ่านข้อความเมื่อเสร็จสิ้น

## เมื่อใช้ (และไม่ใช้)

```text
✓ USE for CPU-bound work: image/video processing, encryption, compression,
  big data parsing, complex calculations, ML inference
✗ DON'T use for I/O (DB, files, HTTP) — the async event loop already handles
  that efficiently; a worker would add overhead for no benefit
```

กฎ: **workers สำหรับ CPU-bound event loop สำหรับ I/O-bound**

## Worker threads vs child_process vs cluster

```text
worker_threads → share memory (efficient data passing), in-process threads — CPU work
child_process  → separate OS processes, run other programs — heavier isolation
cluster        → fork the whole server across CPUs — scale request handling
```

## เหตุใดจึงมีความสำคัญ

Worker threads แก้ไขจุดอ่อนหลักของ Node — CPU-bound tasks ปิดกั้น single-threaded event loop และ freeze concurrent requests ทั้งหมด

การรู้ว่าจะ offload heavy computation ไปยัง worker (ให้ main thread ตอบสนองได้) และสำคัญที่สุด **เมื่อ** ใช้ (CPU-bound เท่านั้น ไม่เคยใช้ I/O) คือสิ่งที่ให้ Node service จัดการการประมวลผลที่หนักเป็นครั้งคราวได้โดยไม่เสียสละ concurrency ที่ทำให้ Node มีค่า

สำหรับ pooling workers ในการผลิต libraries เช่น Piscina จัดการ thread pool อย่างมีประสิทธิภาพ