Sobes.tech
Middle+

Comment fonctionne la boucle d'événements (Event Loop) dans Node.js?

sobes.tech IA

Réponse de l'IA

La boucle d’événements — c’est un mécanisme permettant à Node.js d’effectuer des opérations d’E/S non bloquantes, malgré le fait que JavaScript soit un langage mono-thread. La boucle d’événements surveille en continu la pile d’appels, la file de rappels et diverses files d’événements (temporisateurs, E/S).

Principales phases de la boucle d’événements :

  1. timers : Exécute les rappels planifiés avec setTimeout() et setInterval().
  2. pending callbacks : Exécute les rappels des opérations d’entrée/sortie système (par exemple, erreurs réseau), retardés jusqu’à la prochaine itération de la boucle d’événements.
  3. idle, prepare : Phases internes de la boucle d’événements.
  4. poll :
    • Calcule combien de temps bloquer et interroger les opérations d’entrée/sortie.
    • Traite les événements dans la file de rappels E/S lorsque leur nombre atteint une limite ou que le temps est écoulé.
  5. check : Exécute les rappels planifiés avec setImmediate().
  6. close callbacks : Exécute les rappels de fermeture, par exemple, socket.destroy().

process.nextTick() et les micro-tâches (promesses, queueMicrotask()) s’exécutent entre les phases de la boucle d’événements et avant de passer à la phase suivante ou de terminer la phase en cours. process.nextTick() a une priorité plus élevée que les micro-tâches.

// Exemples de planification de tâches
console.log('Début');

setTimeout(() => {
  console.log('Timer 0');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

process.nextTick(() => {
  console.log('nextTick');
});

Promise.resolve().then(() => {
  console.log('Promise');
});

console.log('Fin');

// Ordre d’exécution typique (peut varier selon la version de Node.js et la charge) :
// Début
// Fin
// nextTick
// Promise
// Timer 0  (exécuté dans la phase timers)
// setImmediate (exécuté dans la phase check)

La boucle d’événements permet à Node.js de traiter efficacement de nombreuses requêtes parallèles sans créer un thread séparé pour chacune, ce qui assure de hautes performances.