Les étapes de la boucle d'événements Node.js

La boucle d'événements est un mécanisme crucial dans Node.js qui gère les rappels asynchrones, permettant à la plateforme d'effectuer des opérations d'E/S non bloquantes. Voici une ventilation détaillée de 6 points clés du fonctionnement de la boucle événementielle.

1. Pile d'appels
2. Inscription par rappel
3. Files d'attente de rappel
4. Surveillance continue
5. Achèvement des opérations asynchrones
6. Flux d'exécution

1. Pile d'appels : Comprendre la pile d'appels en JavaScript :

• La pile d'appels est l'endroit où le code JavaScript est exécuté. Lorsqu'une fonction est appelée, elle est placée sur la pile d'appels. Une fois l'exécution de la fonction terminée, elle est retirée de la pile.
• Si la pile d'appels est occupée à exécuter des fonctions, la boucle d'événements attend que la pile soit vide avant de vérifier les files d'attente de rappel.

2. Enregistrement de rappel : comment les opérations asynchrones sont gérées :

• API Web et API Node.js : lorsqu'une opération asynchrone (comme une lecture de fichier, une requête réseau ou une minuterie) est lancée, le rappel correspondant est enregistré auprès d'une API Web (dans le navigateur) ou d'une API Node.js. (dans le serveur).
• Exemple :
  • Pour setTimeout(), lorsque le timer expire, le rappel la fonction est enregistrée avec la boucle d'événements à exécuter dans la file d'attente des macrotâches.
  • Pour une requête réseau effectuée via http.get(), lorsque les données est reçu, le rappel est placé dans la file d'attente pour traitement.

3. Files d'attente de rappel : macrotâche vs microtâche :
Node.js gère deux types principaux de files d'attente de rappel

• File d'attente des macrotasks (Task Queue) : cette file d'attente gère les rappels d'opérations telles que setTimeout, setInterval, les opérations d'E/S et d'autres tâches qui prennent du temps. Les tâches de cette file d'attente ne sont exécutées qu'une fois que toutes les microtâches ont été traitées et que la pile d'appels est vide.
• File d'attente Microtask : cette file d'attente comprend les rappels de Promises et process.nextTick(). Les microtâches ont une priorité plus élevée et sont exécutées immédiatement après que la pile d'appels soit vide, avant de traiter les macrotâches.

4. Surveillance continue par la boucle d'événements :

• La boucle d'événements vérifie en permanence la pile d'appels et les files d'attente de rappel pour déterminer si des tâches doivent être exécutées. Cela permet à Node.js de gérer plusieurs opérations asynchrones simultanément sans bloquer le thread principal.

5. Achèvement des opérations asynchrones :
Une fois une opération asynchrone terminée, la fonction de rappel correspondante est ajoutée à la file d'attente appropriée :

• Si un minuteur défini par setTimeout() expire, le rappel associé est enregistré dans la file d'attente des macrotâches, en attente d'être exécuté une fois la pile actuelle et toutes les microtâches traitées.

6. Flux d'exécution : déplacer les tâches vers la pile d'appels :

• Lorsque la pile d'appels est vide, la boucle d'événements traite d'abord toutes les tâches de la file d'attente des microtâches. Cela garantit que les résolutions de promesses et autres microtâches sont traitées dès que possible.
• Une fois toutes les microtâches terminées, la boucle d'événements passera à la file d'attente des macrotâches et exécutera une tâche à la fois. L'exécution de cette tâche se poursuit jusqu'à ce que la pile soit à nouveau vide, auquel cas la boucle vérifie à nouveau les files d'attente.
• Une fois la tâche exécutée, elle est supprimée de la pile d'appels

Exemples d'exécution de boucle d'événement :

console.log('Start');

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

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

console.log('End');

Sortie :

Start
End
Promise
Timeout

Dans cet exemple :

• Les journaux synchrones (« Début » et « Fin ») s'exécutent en premier, les ajoutant à la pile d'appels.
• Le rappel setTimeout est enregistré dans la file d'attente des macrotâches.
• La promesse se résout, ajoutant son rappel à la file d'attente des microtâches.
• Une fois la pile d'appels effacée, la boucle d'événements traite la file d'attente des microtâches (« Promise ») avant de passer à la file d'attente des macrotâches (« Timeout »).

La boucle d'événements est une fonctionnalité essentielle de Node.js qui permet une gestion efficace des opérations asynchrones. En surveillant en permanence la pile d'appels et les files d'attente de rappel, il garantit que les tâches sont traitées de manière non bloquante. L'enregistrement des rappels dans les API Web et les API Node.js est essentiel pour maintenir la réactivité des applications, permettant à Node.js de gérer efficacement de nombreuses opérations simultanées.

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!