Çfarë është event loop në Node.js dhe si funksionon?

Question

Accepted Answer

**Event loop** është mekanizmi që lejon Node.js me një fije të vetme të kryejë **I/O jo-bllokues**. Ai përpunon vazhdimisht një radhë të callback-eve: ndërsa JavaScript juaj ekzekutohet në një fije, operacionet I/O zhvendosen, dhe callback-et e tyre ekzekutohen nga loop-i kur përfundojnë.

## Fazat e loop-it

Çdo iteracion ("tick") kalon përmes fazave të renditura, secila me radhën e vet të callback-eve:

```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-et ekzekutohen ndërmjet fazave (prioritet i lartë)

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

Pas çdo faze (dhe pas kodit sinkron), Node zbraz **microtask-et**: callback-et `process.nextTick` fillimisht, pastaj callback-et Promise — *përpara* se të vazhdojë. Kjo është pse një Promise e zgjidhur ekzekutohet përpara `setTimeout(…, 0)`.

## Pse lejon njëkohshmëri pa fije

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

## Rregulli kardinal: mos blloko loop-in

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

Bllokimi i një fije të vetme ndal të gjithë trajtimin e kërkesave. Zhvendosni punën intensive të CPU-it për worker threads.

## Pse është e rëndësishme

Event loop-i është zemra e modelit të performancës Node — të kuptuarit e fazave të tij dhe prioritetit të microtask-eve shpjegon renditjen async, pse Node përballon konkurrencë të madhe në një fije, dhe rregullin kritik të mos e bllokuar atë kurrë.

Është themelor për shkrimin e kodit Node të saktë dhe performant dhe për debugimin e renditjes së ekzekutimit async të befasishme.