Que signifient les E/S dans nodejs

Dans nodejs, « E/S » signifie entrée et sortie, indiquant généralement les opérations « E/S ». Les opérations « E/S » peuvent être divisées en exécution série monothread et exécution parallèle multithread. Exécution séquentielle, toute exécution lente entraînera le blocage de l’exécution ultérieure du code.

L'environnement d'exploitation de cet article : système Windows 10, nodejs version 12.19.0, ordinateur Dell G3.

Que signifient les E/S dans nodejs

De nombreuses personnes connaissent le serveur Nginx. Nginx est écrit en C pur et est utilisé comme serveur Web. Il dispose de nombreux services tels que le proxy inverse et l'équilibrage de charge. Les serveurs Node et Nginx sont similaires dans le sens où ils sont pilotés par les événements.

JavaScript dans le navigateur est exécuté sur un seul thread et partage également le même thread avec le rendu de l'interface utilisateur. Lorsque JavaScript est exécuté, le rendu et la réponse de l'interface utilisateur doivent être dans un état stagnant. (Si le temps d'exécution du script dépasse 100 millisecondes, l'utilisateur aura l'impression que la page est bloquée). Face à ces situations, nous penserons à des méthodes asynchrones pour éliminer ces problèmes d'attente, et nous n'introduireons pas les concepts d'asynchrone et de synchronisé.

Ensuite, examinons de plus près les fonctionnalités d'E/S événementielles et non bloquantes de NodeJS. Comprendre celles-ci a une signification plus profonde pour nous afin de mieux apprendre le développement NodeJS et de créer une plate-forme Web hautes performances.

1. Aperçu des opérations d'E/S :

Les opérations d'E/S sont familières à tout développeur. Parlons maintenant brièvement des opérations d'E/S de NodeJS. Les opérations d'E/S sont divisées en : exécution série monothread ; exécution parallèle multithread. Les deux méthodes ont leurs propres avantages et inconvénients.Le coût du multithread est le coût élevé de la création de threads et du changement de contexte de thread pendant l'exécution, ainsi que les problèmes de verrouillage et de synchronisation d'état du multithread. L'installation monothread est exécutée de manière séquentielle. Toute lenteur d'exécution entraînera le blocage du code d'exécution ultérieur. La description de l'exécution en série des tâches (conceptuellement similaire à l'exécution synchrone) et de l'exécution parallèle des tâches est la suivante :

Utilisez un seul thread dans NodeJS pour éviter les blocages et les problèmes de synchronisation d'état, et utilisez l'I asynchrone. /O , empêchant les threads uniques de se bloquer afin de mieux utiliser le processeur. Les E/S asynchrones s'attendent à ce que les appels d'E/S ne bloquent plus les opérations ultérieures et allouent le temps d'attente d'origine pour l'achèvement des E/S aux autres entreprises requises pour l'exécution. ​​

Souvent, certains développeurs sont confus quant aux concepts d'asynchrone/synchrone et de blocage/non bloquant, et les deux ne sont pas liés. Le blocage des E/S signifie qu'après l'appel, vous devez attendre que le niveau du noyau système termine toutes les opérations avant la fin de l'appel. Les E/S non bloquantes reviennent immédiatement après avoir été appelées. Concernant les E/S bloquantes et les E/S non bloquantes, il y a la figure suivante :

2 Analyse des E/S asynchrones NodeJS :

Boucle d'événement : Lorsque le processus démarre, Node créera un while. (true ), le processus de chaque exécution du corps de la boucle est appelé Tick, et le processus de chaque Tick consiste à vérifier s'il y a du temps à traiter.

Observateurs : Il y a un ou plusieurs observateurs dans chaque boucle temporelle. Le processus permettant de déterminer s'il y a des événements à traiter consiste à demander à ces observateurs s'il y a des événements à traiter.

Objet de requête : dans le processus de transition depuis JavaScript initiant un appel au noyau complétant l'opération d'E/S, il existe un produit intermédiaire, qui est l'objet de requête.

Pool de threads d'E/S : assemblez la requête, envoyez-la au pool de threads d'E/S pour exécution, terminez la première étape de l'opération d'E/S et entrez la deuxième partie de la notification de rappel. (Sous Windows, après l'appel de l'opération d'E/S dans le pool de threads, le résultat obtenu sera stocké dans l'attribut req->result, puis PostQueuedCompletionStatus() sera appelé pour informer IOCP que l'opération d'objet en cours a été terminé.)

Les E/S asynchrones sont comme indiqué ci-dessous :

3. Exemple de programmation asynchrone NodeJS :

Les concepts associés aux E/S asynchrones ont été introduits plus tôt, voici un exemple d'E/S asynchrones O opération :

var config = require('./config.json');
var fs = require("fs");
var http = require('http');
var url_module = require("url");
http.createServer(function (request, response) {
var key = url_module.parse(request.url).query.replace('key=', '');
switch (request.method) {
   case 'GET':  // Asynchronous Response Generation
       fs.readFile(config.dataPath + key, 'utf8', function(err, value) {
           if (err) {
               // Return File Not Found if file hasn't yet been created
               response.writeHead(404, {'Content-Type': 'text/plain'});
               response.end("The file (" + config.dataPath + key + ") does not yet exist.");
           } else {
               // If the file exists, read it and return the sorted contents
               var sorted = value.split(config.sortSplitString).sort().join('');
               response.writeHead(200, {'Content-Type': 'text/plain'});
               response.end(sorted);
           }
       });
       break;
   case 'POST':  // Synchronously append POSTed data to a file
       var postData = '';
       request
           .on('data', function (data) {
               postData += data;
           })
           .on('end', function () {
               fs.appendFile(config.dataPath + key, postData, function(err) {
                   if (err) {
                       //  Return error if unable to create/append to the file
                       response.writeHead(400, {'Content-Type': 'text/plain'});
                       response.end('Error: Unable to write file: ' + err);
                   } else {
                       //  Write or append posted data to a file, return "success" response
                       response.writeHead(200, {'Content-Type': 'text/plain'});
                       response.end('success');
                   }
               });
           });
       break;
   default:
       response.writeHead(400, {'Content-Type': 'text/plain'});
       response.end("Error: Bad HTTP method: " + request.method);
}
}).listen(config.serverPort);
console.log('synchronous server is running: ', config.serverPort);

Apprentissage recommandé : "Tutoriel vidéo 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!