Comment nodejs gère les calculs intensifs

Comment nodejs gère-t-il les calculs intensifs ?

Solution CPU intensive Nodejs

Parlons d'abord des avantages du thread unique nodejs :

Recommandé : "javascript avancé Tutoriel 》

Hautes performances Par rapport à PHP, il évite la surcharge liée à la création et au changement fréquents de threads, s'exécute plus rapidement et consomme moins de ressources.

Thread-safe, pas besoin de s'inquiéter de la même variable lue et écrite par plusieurs threads, provoquant le crash du programme.

Asynchrone monothread et non bloquant. En fait, les E/S d'accès nodejs sous-jacentes sont multithread. Blocage/non bloquant et asynchrone/synchronisation sont deux concepts différents. mais le blocage le fait certainement. Synchrone, c'est un peu compliqué. S'il vous plaît, donnez-moi un exemple. Je suis allé à la cantine pour préparer un repas, j'ai choisi le set A, puis le personnel m'a aidé à préparer le repas. pour que le personnel me prépare le repas, cette situation serait C'est ce qu'on appelle la synchronisation ; si le personnel m'aide à préparer à manger, les personnes derrière moi commencent à commander, afin que le service de commande dans toute la cantine ne s'arrête pas parce que je suis en attente de l'ensemble A. Cette situation est appelée non bloquante. Cet exemple illustre simplement la situation synchrone mais non bloquante. De plus, si j'achète une boisson en attendant que le repas soit servi, puis que je retourne chercher le repas prévu lorsque mon numéro est appelé, ma boisson a déjà été achetée. De cette façon, j'effectue également la tâche d'acheter une boisson. boire en attendant que le repas soit servi. Appeler le numéro équivaut à Une fois le rappel exécuté, il est asynchrone et non bloquant. Si, lorsque j'achète une boisson, mon numéro a été appelé pour obtenir le repas prévu, mais que je dois attendre longtemps pour obtenir la boisson, il se peut donc que je ne reçoive le numéro A que longtemps après que mon numéro de repas ait été appelé dans le lobby, qui est une situation de blocage d'un seul thread.

Multi-threading :

Le thread est une unité de base de la planification du processeur. Un processeur ne peut exécuter qu'une seule tâche de thread.

Nodejs peut également effectuer des tâches multi-thread, telles que référencer le module TAGG/TAGG2, mais tagg/tagg2 utilise la bibliothèque pthread et la classe V8::Isolate pour implémenter la fonction multi-threading js selon. Aux règles, nos fonctions exécutées dans les threads ne peuvent pas utiliser l'API de base de nodejs, comme les modules fs et crypto, il y a donc encore de grandes limitations.

Processus multiples :

Dans les navigateurs prenant en charge HTML5, nous pouvons utiliser webworker pour lancer des calculs fastidieux dans le processus de travail en vue de son exécution, afin que le processus principal ne soit pas bloqué et que le utilisateur Il n'y aura pas de sensation de décalage.

Ici, nous devons utiliser le module child_process de nodejs. child_process fournit la méthode fork, qui peut démarrer un fichier nodejs et le considérer comme un processus de travail. Une fois que le travailleur a terminé son travail, le résultat sera envoyé à. le processus principal, puis le travailleur quittera automatiquement, afin que nous puissions utiliser plusieurs processus pour résoudre le problème du blocage du thread principal.

var express = require('express');
var fork = require('child_process').fork;
var app = express();
app.get('/', function(req, res){
  var worker = fork('./work.js') //创建一个工作进程
  worker.on('message', function(m) {//接收工作进程计算结果
          if('object' === typeof m && m.type === 'fibo'){
                   worker.kill();//发送杀死进程的信号
                   res.send(m.result.toString());//将结果返回客户端
          }
  });
  worker.send({type:'fibo',num:~~req.query.n || 1});
  //发送给工作进程计算fibo的数量
});
app.listen(7878);

Nous écoutons le port 7878 via express. Pour chaque demande de l'utilisateur, nous allons créer un processus enfant, transmettre le paramètre n au processus enfant en appelant la méthode worker.send, et en même temps écouter. l'événement message du message envoyé par le processus enfant, répondez le résultat au client.

Voici le contenu du fichier forked work.js :

var fibo = function fibo (n) {//定义算法
   return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1;
}
process.on('message', function(m) {
//接收主进程发送过来的消息
          if(typeof m === 'object' && m.type === 'fibo'){
                  var num = fibo(~~m.num);
                  //计算jibo
                  process.send({type: 'fibo',result:num})
                  //计算完毕返回结果       
          }
});
process.on('SIGHUP', function() {
        process.exit();//收到kill信息，进程退出
});

Nous définissons d'abord la fonction fibo pour calculer le tableau de Fibonacci, puis écoutons le message envoyé par le fil principal. Le calcul est terminé. Envoyez ensuite le résultat au thread principal. En même temps, il écoute également l'événement SIGHUP du processus. Lorsque cet événement est déclenché, le processus se termine.

Une chose que nous devons noter ici est que la méthode kill du thread principal ne provoque pas réellement la sortie du processus enfant, mais déclenche l'événement SIGHUP du processus enfant. La véritable sortie repose toujours sur le processus. sortie().

Résumé :

L'utilisation de la méthode fork du module child_process peut en effet nous permettre de résoudre le problème du blocage mono-thread des tâches gourmandes en CPU. En même temps, cela ne fait pas. il est impossible d'utiliser Node.js comme le package tagg. Limitations de l'API principale.

Node.js asynchrone à thread unique ne signifie pas qu'il ne bloquera pas. Effectuer trop de tâches sur le thread principal peut bloquer le thread principal et affecter les performances de l'ensemble du programme, nous devons donc le faire. soyez très prudent lorsque vous gérez un grand nombre de tâches. Pour les tâches gourmandes en CPU telles que les opérations de bouclage, d'épissage de chaînes et de virgule flottante, diverses technologies sont raisonnablement utilisées pour attribuer des tâches à des sous-threads ou à des sous-processus, en conservant le Thread principal de Node.js ouvert.

L'utilisation de threads/processus n'est pas sans surcharge. Réduire autant que possible le nombre de threads/processus créés et détruits peut améliorer les performances globales et la probabilité d'erreur de notre système.

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!