Event loop ใน Node.js คืออะไร และมันทำงานอย่างไร?

Question

IT Interview Practice · Accepted Answer

**event loop** คือกลไกที่ให้ Node.js แบบ single-threaded สามารถทำ **non-blocking I/O** ได้ มันประมวลผลคิวของ callbacks อย่างต่อเนื่อง: ในขณะที่ JavaScript ของคุณทำงานบนหนึ่ง thread, I/O operations จะถูกส่งต่อออกไป และ callbacks ของพวกมันจะรัน loop เมื่อเสร็จสิ้น

## ขั้นตอนของ loop

แต่ละ iteration ("tick") เคลื่อนผ่านขั้นตอนที่เรียงลำดับ, แต่ละขั้นตอนมี callback queue ของตัวเอง:

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← expired timer callbacks
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← retrieve new I/O; execute their callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Microtasks รันระหว่างขั้นตอน (high priority)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // timers phase (macrotask)
setImmediate(() => console.log("3"));      // check phase
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — highest priority
console.log("6");
// Output: 1, 6, 5, 4, 2/3 (timer vs immediate order can vary)
```

หลังจากแต่ละขั้นตอน (และหลังจาก sync code), Node จะ drain **microtasks**: `process.nextTick` callbacks ก่อน, แล้วตาม Promise callbacks — *ก่อน* ที่จะเคลื่อนต่อไป นี่คือเหตุผลว่าทำไม resolved Promise จึงรันก่อน `setTimeout(…, 0)`

## มันช่วยให้ concurrency โดยไม่ต้องใช้ threads ได้อย่างไร

```text
A DB query or file read is handed to the OS/thread pool → Node keeps running
other code → when the result is ready, its callback is queued → the loop runs it.
One thread, thousands of in-flight operations.
```

## กฎพื้นฐาน: อย่า block loop

```js
// ❌ a long synchronous loop freezes EVERYTHING — no other callback can run
while (Date.now() - start < 5000) {}
```

การ block single thread หยุดการจัดการคำขอทั้งหมด ส่งต่อ CPU-heavy work ไปยัง worker threads

## ทำไมสิ่งนี้จึงสำคัญ

Event loop คือหัวใจของ performance model ของ Node — การทำความเข้าใจ phases และ microtask priority ของมันอธิบายถึง async ordering, เหตุผลว่าทำไม Node จึงจัดการ concurrency ขนาดใหญ่บน thread เดียว, และกฎ critical ที่ไม่ควร block มัน

มันเป็นพื้นฐานสำหรับการเขียน Node code ที่ถูกต้องและ performant และสำหรับการแก้ปัญหา async execution order ที่น่าประหลาดใจ

ขั้นตอนของ loop

Microtasks รันระหว่างขั้นตอน (high priority)

มันช่วยให้ concurrency โดยไม่ต้องใช้ threads ได้อย่างไร

กฎพื้นฐาน: อย่า block loop

ทำไมสิ่งนี้จึงสำคัญ

คำถามที่เกี่ยวข้อง