Comment fonctionne la boucle d'événements dans Node.js ?

La boucle d'événements est un concept central de Node.js qui lui permet de gérer efficacement les opérations asynchrones. Voici une explication simplifiée de son fonctionnement :

1. Nature à filetage unique

Node.js fonctionne sur un seul thread. Cela signifie qu’il ne peut exécuter qu’un seul morceau de code à la fois. Cependant, Node.js est conçu pour gérer de nombreuses opérations simultanément sans nécessiter plusieurs threads.

2. E/S non bloquantes

Node.js utilise des opérations d'E/S non bloquantes. Lorsque Node.js effectue des tâches telles que lire des fichiers, interroger une base de données ou effectuer des requêtes réseau, il n'attend pas la fin de ces tâches avant de passer à la tâche suivante. Au lieu de cela, il continue d'exécuter d'autres codes pendant que ces tâches sont en cours de traitement.

3. Mécanisme de boucle d'événement

La boucle d'événements est chargée de gérer l'exécution du code et de gérer les événements asynchrones. Il vérifie en permanence la « file d’attente » des tâches et décide lesquelles exécuter. Voici une présentation étape par étape :

• Initialiser : lorsqu'une application Node.js démarre, elle initialise et configure l'environnement.
• Phase d'exécution : Node.js exécute tout code initial de manière synchrone. S'il existe des tâches asynchrones (comme la lecture de fichiers ou les requêtes HTTP), elles sont transmises aux API du système.
• Phases de la boucle d'événement : la boucle d'événement comporte plusieurs phases et traite les tâches de chaque phase dans un ordre spécifique :
  • Phase des minuteries : exécute les rappels programmés par setTimeout() et setInterval().
  • Phase de rappels IO : exécute des rappels pour les opérations d'E/S, telles que des lectures de fichiers ou des requêtes réseau.
  • Inactif, phase de préparation : phase interne utilisée pour les tâches système.
  • Phase d'interrogation : récupère les nouveaux événements d'E/S et exécute leurs rappels. Si la file d'attente d'interrogation est vide, elle vérifiera s'il y a des rappels dans la file d'attente setImmediate().
  • Phase de vérification : exécute les rappels planifiés par setImmediate().
  • Phase de rappel de fermeture : gère les événements de fermeture, tels que ceux émis par socket.on('close').
• Revérifier et quitter : Si la boucle d'événements n'a plus de tâches à traiter, elle se terminera, permettant au programme de se terminer. S'il y a des tâches encore en attente, l'exécution continuera.

4. File d'attente de rappel

Les tâches asynchrones, une fois terminées, placent leurs rappels dans une file d'attente. La boucle d'événements sélectionne ces rappels dans la file d'attente et les exécute dans l'ordre.

5. File d'attente de microtâches (coche suivante)

Outre la file d'attente principale, il existe également une file d'attente de microtâches (ou file d'attente de ticks suivants) où les rappels planifiés avec process.nextTick() ou les gestionnaires .then() des promesses sont mis en file d'attente. Les microtâches ont la priorité sur les rappels réguliers, ce qui signifie qu'elles sont exécutées une fois l'opération en cours terminée mais avant que la boucle d'événements ne passe à la phase suivante.

Exemple

Voici un exemple simple pour illustrer le fonctionnement de la boucle d'événements :

const fs = require('fs');

console.log('Start');

fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log('File read complete');
});

console.log('End');

Sortie :

Start
End
File read complete

Explication :

1. console.log('Démarrer'); et console.log('Fin'); sont exécutés de manière synchrone.
2. fs.readFile lance une opération de lecture de fichier asynchrone et continue d'exécuter la ligne de code suivante sans attendre.
3. Une fois l'opération de lecture du fichier terminée, son rappel (console.log('File read complete');) est poussé vers la file d'attente de rappel de la boucle d'événements.
4. La boucle d'événements traite le rappel une fois l'exécution du code synchrone terminée.

La boucle d'événements permet à Node.js de gérer efficacement de nombreuses opérations à la fois, bien qu'il soit monothread, en déléguant les opérations au système et en gérant leurs résultats de manière asynchrone.

La Boucle d'événements orchestre l'exécution des tâches, en donnant la priorité à la File d'attente des microtâches pour garantir que les promesses et les opérations associées sont résolues rapidement avant de passer aux tâches dans la File d'attente des tâches principale (Tâche Macro).

Cette dynamique permet à JavaScript de gérer un comportement asynchrone complexe dans un environnement monothread.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!