Apprentissage visuel nodejs : boucle d'événements [démonstration d'animation]

Cet article vous aidera à apprendre la boucle d'événement Node grâce à l'animation. J'espère qu'il vous sera utile !

Nous avons tous entendu dire que JavaScript et Node.js sont monothread, mais qu'est-ce que cela signifie réellement ?

Cela signifie que JavaScript ne peut faire qu'une seule chose à la fois. Par exemple, nous ne pouvons pas multiplier et additionner des nombres en même temps. Nous faisons généralement cela dans l’ordre. On additionne puis on multiplie et vice versa. Les ordinateurs modernes sont si rapides que les résultats de deux ou plusieurs tâches consécutives semblent être calculés simultanément, à quelques exceptions près. [Recommandation de didacticiel connexe : Tutoriel vidéo Nodejs]

Nous avons tous essayé de récupérer les données de ce site Web lent, ou avons attendu plus de 30 secondes avant d'obtenir les résultats de la requête de base de données. Voulons-nous empêcher un seul thread d'effectuer plus de tâches parce que la requête de la base de données est lente ? Cependant, Node.js n'arrête pas d'exécuter d'autres opérations, car Libuv est une bibliothèque C++ responsable des boucles d'événements et du traitement asynchrone des requêtes réseau, de la résolution DNS, des opérations du système de fichiers, des données. cryptage, etc. 我们是否想因为数据库查询速度慢而阻止单线程执行更多任务？然而，Node.js 并没有停止运行其他操作，因为 Libuv 是一个 C++ 库，负责事件循环和异步处理网络请求、DNS 解析、文件系统操作、数据加密等任务。

当 Node.js 处理诸如数据库查询之类的任务时，幕后会发生什么？我们将按照这段代码一步一步来探索它。

这是我们的示例代码

V8 JavaScript 引擎管理调用堆栈，这是跟踪我们程序的哪个部分正在运行的重要部分。每当我们调用 JavaScript 函数时，它都会被推送到调用堆栈。一旦函数到达其结尾或return语句，它就会从堆栈中弹出。

在我们的示例中，代码行 console.log('Starting Node.js') 被添加到调用堆栈并打印 Starting Node.js 到控制台。通过这样做，它到达log函数的末尾并从调用堆栈中删除。

以下代码行是一个数据库查询。这些任务会立即弹出，因为它们可能需要很长时间。它们被传递给 Libuv，后者在后台异步处理它们。同时，Node.js 可以在不阻塞其单线程的情况下继续运行其他代码。

将来，Node.js 将知道如何处理查询，因为我们已将回调函数与处理任务结果或错误的指令相关联。在我们的例子中，它是一个简单的 console.log，但它可能是复杂的业务逻辑或生产应用程序中的数据处理。

当 Libuv 在后台处理查询时，我们的 JavaScript 没有被阻塞，可以继续使用 console.log(”Before query result”)

Que se passe-t-il en coulisses lorsque Node.js gère des tâches telles que les requêtes de base de données ? Nous allons l'explorer étape par étape en suivant ce code.

Voici notre exemple de code

Le moteur JavaScript V8 gère la pile d'appels, qui est une partie importante du suivi de la partie de notre programme en cours d'exécution. Chaque fois que nous appelons une fonction JavaScript, elle est poussée vers le haut de la pile d'appels. Une fois qu'une fonction atteint sa fin ou une instruction return, elle est retirée de la pile.

Dans notre exemple, la ligne console.log('Starting Node.js') est ajoutée à la pile d'appels et imprime Starting Node.js sur la console. Ce faisant, il atteint la fin de la fonction log et est supprimé de la pile d'appels.

La ligne de code suivante est une requête de base de données. Ces tâches apparaissent immédiatement car elles peuvent prendre beaucoup de temps. Ils sont transmis à Libuv, qui les traite de manière asynchrone en arrière-plan. Dans le même temps, Node.js peut continuer à exécuter d’autres codes sans bloquer son seul thread.

À l'avenir, Node.js saura gérer les requêtes car nous avons associé des fonctions de rappel à des instructions pour gérer les résultats ou les erreurs des tâches. Dans notre cas, il s'agit d'un simple console.log, mais il peut s'agir d'une logique métier complexe ou d'un traitement de données dans une application de production.

Lorsque Libuv traite la requête en arrière-plan, notre JavaScript n'est pas bloqué et peut continuer à utiliser console.log("Avant le résultat de la requête").

🎜🎜🎜🎜Une fois la requête terminée, son rappel sera poussé vers la file d'attente des événements d'E/S pour être exécuté immédiatement* 🎜. 🎜 * La boucle d'événements connecte la file d'attente à la pile d'appels. Il vérifie si ce dernier est vide et déplace le premier élément de la file d'attente pour exécution. 🎜🎜🎜🎜🎜Le code est disponible sur 🎜github.com/fabrillallo… 🎜🎜🎜🎜🎜Quiz sur Event Loop 🎜🎜 Essayez de comprendre le code suivant imprimé sur la console. 🎜

Conclusion

Les boucles d'événements, les délégués et les mécanismes de traitement asynchrone sont le secret de Node.js qui gère des milliers de connexions, lit/écrit d'énormes fichiers, gère des minuteries tout en travaillant sur d'autres parties de notre élément de code.

Dans l'article, nous avons vu le rôle important de Libuv et sa capacité à gérer de nombreuses tâches potentiellement longues. Dans le même temps, nous avons découvert la boucle d'événements et son rôle de pont/connecteur entre les rappels d'opérations asynchrones et la pile d'appels dans la file d'attente des événements d'E/S. Dans les articles suivants, nous explorerons plus en détail comment les différentes étapes de la boucle d'événements gèrent les timers, I/O, promises et ticks.

Adresse originale en anglais : https://dev.to/nodedoctors/an-animated-guide-to-nodejs-event-loop-3g62

Pour plus de connaissances sur les nœuds, veuillez visiter : Tutoriel Nodejs !

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!