Event Loop in Node.js – prestazioni, trappole e loro eliminazione

L'event loop in Node.js è il cuore del modello di esecuzione asincrono. Grazie all'approccio a thread singolo consente di gestire centinaia di migliaia di connessioni simultanee, ma solo a condizione che il codice non blocchi il thread. In questo articolo esamineremo come funziona l'event loop in Node.js, quali problemi compaiono più spesso negli ambienti di produzione e quali tecniche è possibile adottare per mantenere un'alta capacità di throughput.

Struttura e fasi dell'event loop

Node.js si basa su libuv, una libreria C che implementa un event loop a quattro livelli. Le fasi includono timers, pending callbacks, idle, prepare, poll, check e close callbacks. Ogni fase ha la propria coda di task; al termine di una fase si passa alla successiva. Perciò comprendere in quale fase finiscono le operazioni specifiche è fondamentale per l'ottimizzazione.

Perché il blocco del thread distrugge le prestazioni

Node.js è a thread singolo per quanto riguarda JavaScript. Se nel codice compare un'operazione intensiva di CPU – ad esempio un ciclo while(true) o una costosa serializzazione JSON – essa occupa l'intero ciclo dell'event loop e impedisce la gestione di altri eventi. L'effetto è un aumento della latenza e una diminuzione del numero di richieste gestite al secondo.

// esempio di ciclo bloccante
while (true) {
  // simulazione di calcolo pesante
  const now = Date.now();
  if (now % 1000000 === 0) break;
}

In pratica questi frammenti compaiono inconsapevolmente – ad esempio durante un ordinamento non ottimale di grandi array o una sincronizzazione I/O (fs.readFileSync). Perciò ogni chiamata sincrona in codice di produzione dovrebbe essere valutata con attenzione.

Monitorare l'event loop in Node.js

Per osservare lo stato del loop si usano più spesso il modulo integrato perf_hooks e lo strumento clinic. perf_hooks.monitorEventLoopDelay() restituisce statistiche sui ritardi, che possono essere inviate a Prometheus o ai log.

const { monitorEventLoopDelay } = require('perf_hooks');
const h = monitorEventLoopDelay({ resolution: 20 });
 h.enable();
 setInterval(() => {
   console.log(`p95: ${h.percentile(95)}ms`);
 }, 5000);

Un monitoraggio regolare consente di rilevare picchi improvvisi di latenza, spesso dovuti al blocco del thread o a operazioni I/O poco efficienti.

Quando usare async/await e quando restare con gli stream

Async/await semplifica il codice, ma introduce un micro‑task aggiuntivo dopo ogni operazione await. In scenari in cui vengono elaborate centinaia di migliaia di piccole richieste, questo overhead può diventare evidente. Un'alternativa sono gli stream (Readable, Writable) e il metodo .pipe(), che permettono di gestire i dati in modalità back‑pressure, minimizzando il numero di micro‑task.

// elaborazione di un file grande usando gli stream
const fs = require('fs');
const zlib = require('zlib');

fs.createReadStream('big.log')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('big.log.gz'));

Gli stream sono quindi la scelta migliore quando è importante mantenere un throughput costante e un consumo di memoria controllato.

Trappole di prestazioni comuni e loro eliminazione

• Sincronizzazione I/O – sostituire fs.readFileSync con fs.promises.readFile o con gli stream.
• Algoritmi non ottimali – sostituire l'ordinamento O(n²) con Array.prototype.sort o librerie C++ (es. fast-sort).
• Oggetti troppo grandi in memoria – usare Buffer e TypedArray invece di stringhe per il processing binario.
• Mancanza di limiti di concorrenza – introdurre un pool di worker (worker_threads) o un limite di coda (p‑limit).

“L'event loop non è una scatola magica – è un meccanismo che richiede una progettazione consapevole per non diventare un collo di bottiglia.”

Checklist pratica: ottimizzazione dell'event loop

• Usa API asincrone ovunque sia possibile.
• Profilare il codice con clinic doctor e analizzare i grafici dell'event loop.
• Imporre un limite alle operazioni I/O simultanee (es. p-limit).
• Considerare il delegare calcoli pesanti a worker o a servizi esterni.
• Monitorare perf_hooks.monitorEventLoopDelay e impostare allarmi su p95 > 30 ms.

Riepilogo e invito alla collaborazione

Comprendere come funziona l'event loop in Node.js e evitare consapevolmente le operazioni bloccanti è la base per costruire servizi scalabili. Con monitoraggio regolare, profiling e l'applicazione delle tecniche descritte, puoi aumentare significativamente le prestazioni delle tue applicazioni. Se hai bisogno di supporto per audit di prestazioni, ottimizzazione del codice o architettura basata su Node.js, il team di Coderia.it è pronto ad aiutarti – contattaci e miglioriamo insieme i tuoi sistemi.