Node.js இல் event loop என்றால் என்ன மற்றும் அது எப்படி வேலை செய்கிறது?

Question

Accepted Answer

**event loop** என்பது single-threaded Node.js இல் **non-blocking I/O** செயல்பட செய்யும் mechanism ஆகும். இது நிரந்தரமாக callbacks இன் queue ஐ process செய்கிறது: உங்கள் JavaScript ஒரு thread இல் இயங்கும் போது, I/O operations offload செய்யப்பட்டு, அவற்றின் callbacks முடிந்தபின்னர் loop இல் இயங்கப்படுகிறது.

## loop இன் phases

प्रत्येक iteration ("tick") ordered phases இல் நகர்கிறது, ஒவ்வொரு phase க்கும் அதன் சொந்த 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 phases இடையே இயங்குகிறது (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)
```

ப்রत்येक phase க்குப் பிறகு (மற்றும் sync code க்குப் பிறகு), Node **microtasks** ஐ drain செய்கிறது: முதலில் `process.nextTick` callbacks, பின்னர் Promise callbacks — *முன்னர்* move on செய்வதற்கு. இதுவே resolved Promise `setTimeout(…, 0)` இற்கு முன்னால் இயங்குவதற்கான காரணம்.

## இது threads இல்லாமல் concurrency ஐ எப்படி செயல்படுத்துகிறது

```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.
```

## Cardinal rule: loop ஐ block செய்யாதே

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

Single thread ஐ block செய்வது அனைத்து request handling ஐ halt செய்கிறது. CPU-heavy work ஐ worker threads க்கு offload செய்யுங்கள்.

## ஏன் இது முக்கியமானது

Event loop என்பது Node இன் performance model இன் மையமாகும் — அதன் phases மற்றும் microtask priority ஐ புரிந்துகொள்ளுவது async ordering, Node பெரிய concurrency ஐ ஒரு thread இல் எப்படி handle செய்கிறது, மற்றும் அதை block செய்யாதிருப்பதற்கான critical rule ஐ விளக்குகிறது.

இது সঠியான, performant Node code எழுதுவதற்கு மற்றும் surprising async execution order ஐ debug செய்வதற்கு foundational ஆகும்.