რა არის event loop Node.js-ში და როგორ მუშაობს ის?

Question

Accepted Answer

**Event loop** არის მექანიზმი, რომელიც საშუალებას აძლევს ერთ-ნიточი Node.js-ს შეასრულოს **non-blocking I/O**. ის მუდმივად ამუშავებს callback-ების რიგს: სანამ თქვენი JavaScript ერთ ნიმუშზე მუშაობს, I/O ოპერაციები გადაიტანება, და მათი callback-ები ხორციელდება loop-ით როდესაც ისინი დასრულდება.

## loop-ის ფაზები

ყოველი iteration ("tick") გადის დალაგებული ფაზების სხვადსხვა საფეხურზე, თითოეულ თავის callback რიგი აქვს:

```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         │
   └───────────────────────────┘
```

## Microtask-ები ხორციელდება ფაზებს შორის (მაღალი პრიორიტეტი)

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

ყოველი ფაზის შემდეგ (და სინქრონული კოდის შემდეგ), Node უშვებს **microtask-ებს**: ჯერ `process.nextTick` callback-ებს, შემდეგ Promise callback-ებს — *სანამ* წინ გაიწევს. ეს ის იმიტომ, რომ გაწყვილებული Promise წინ ხორციელდება `setTimeout(…, 0)`-ზე.

## რატომ უტევს ეს თანამშრომლობას ნიმუშების გარეშე

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

## კარდინალური წესი: loop-ის ბლოკირება აკრძალული

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

ერთი ნიმუშის ბლოკირება აშლის ყველა მოთხოვნის დამუშავებას. CPU-ბატონი სამუშაო worker-ნიმუშებზე გადაიტანეთ.

## რატომ არის მნიშვნელოვანი

Event loop არის Node-ის კომპეტენტობის მოდელის გული — მის ფაზების და microtask პრიორიტეტის გაცნობიერება აღმოაჩენს async დალაგებას, რატომ ისმენს Node უზარმაზარ თანამშრომლობას ერთ ნიმუშზე, და კრიტიკული წესი რომ არასდროს ბლოკირდეს.

ეს საფუძველია სწორი, წარმადი Node კოდის დასაწერად და გასაკვირი async შესრულების რიგის გამოსწვრაფებისთვის.