Introduction aux processus et applications enfants Node.js

Cet article présente principalement une brève discussion des sous-processus Node.js et des scénarios d'application. Le contenu est assez bon, je vais le partager avec vous maintenant et le donner comme référence.

Contexte

Étant donné que le package Alibaba Cloud RocketMQ) est encapsulé sur la base de C++, il ne prend pas en charge l'instanciation de plusieurs producteurs et consommateurs en un seul Ou, afin de résoudre ce problème, le processus enfant Node.js est utilisé.

Pièges rencontrés lors de l'utilisation

Release : Une fois que la gestion des processus ferme le processus principal, le processus enfant devient un processus du système d'exploitation (pid est 1)

Plusieurs solutions

Traitez le processus enfant comme un processus en cours d'exécution indépendant, enregistrez le pid et la gestion des processus pour fermer le processus principal et fermer le processus enfant lors de la publication

Le processus principal écoute l'événement d'arrêt et ferme activement ses propres sous-processus

Types de sous-processus

1. spawn : exécuter la commande

2. exec : exécuter la commande (nouveau shell)

3. execFile : exécuter le fichier

4. fork : exécuter le fichier

Événements communs pour les processus enfants

1. sortie

2. fermer

3. erreur

4. message

Il y a une différence entre fermer et sortir. close correspond au moment où le flux de données est fermé. L'événement est déclenché à la sortie du processus enfant. Étant donné que plusieurs processus enfants peuvent partager le même flux de données, l'événement close n'est pas nécessairement déclenché lorsqu'un processus enfant se termine, car d'autres processus enfants utilisent le flux de données à ce moment-là.

Flux de données de sous-traitement

1. stdin

2. stdout

3. stderr

Étant donné que le processus principal est le point de départ, le flux de données du sous-processus est opposé à la direction conventionnelle du flux de données stdin : flux d'écriture, sortie standard,. stderr : lire le flux.

spawn

spawn(command[, args][, options])

Exécutez une commande et renvoyez divers résultats d'exécution via le flux de données de données.

Utilisation de base

const { spawn } = require('child_process');

const child = spawn('find', [ '.', '-type', 'f' ]);
child.stdout.on('data', (data) => {
  console.log(`child stdout:\n${data}`);
});

child.stderr.on('data', (data) => {
  console.error(`child stderr:\n${data}`);
});

child.on('exit', (code, signal) => {
  console.log(`child process exit with: code $[code], signal: ${signal}`);
});

Paramètres communs

{
  cwd: String,
  env: Object,
  stdio: Array | String,
  detached: Boolean,
  shell: Boolean,
  uid: Number,
  gid: Number
}

Concentrez-vous sur l'attribut détaché. Définir détaché sur true consiste à préparer le processus enfant à s'exécuter de manière indépendante. Le comportement spécifique du processus enfant est lié au système d'exploitation. Différents systèmes se comportent différemment. Le processus enfant du système Windows aura sa propre fenêtre de console et le processus enfant du système POSIX deviendra le nouveau groupe de processus et chef de session.

À l'heure actuelle, le processus enfant n'est pas complètement indépendant. Les résultats en cours d'exécution du processus enfant seront affichés sur le flux de données défini par le processus principal, et la sortie du processus principal affectera le fonctionnement de le processus enfant. Lorsque stdio est défini sur ignore et que child.unref(); est appelé, le processus enfant commence à s'exécuter véritablement de manière indépendante et le processus principal peut se terminer indépendamment.

exec

exec(command[, options][, callback])

Exécuter une commande et renvoyer le résultat via le paramètre de rappel lorsque la commande est. n'est pas terminé, les résultats partiels seront mis en cache dans la mémoire système.

const { exec } = require('child_process');

exec('find . -type f | wc -l', (err, stdout, stderr) => {
  if (err) {
    console.error(`exec error: ${err}`);
    return;
  }

  console.log(`Number of files ${stdout}`);
});

Le meilleur des deux mondes - spawn au lieu d'exec

Puisque le résultat de exec est renvoyé une fois , après son retour auparavant, il était mis en cache en mémoire, donc lorsque la sortie de la commande shell exécutée est trop volumineuse, l'utilisation de exec pour exécuter la commande ne peut pas terminer notre travail comme prévu. À ce stade, nous pouvons utiliser spawn au lieu d'exécuter exec. la commande shell.

const { spawn } = require('child_process');

const child = spawn('find . -type f | wc -l', {
  stdio: 'inherit',
  shell: true
});

child.stdout.on('data', (data) => {
  console.log(`child stdout:\n${data}`);
});

child.stderr.on('data', (data) => {
  console.error(`child stderr:\n${data}`);
});

child.on('exit', (code, signal) => {
  console.log(`child process exit with: code $[code], signal: ${signal}`);
});

execFile

child_process.execFile(file[, args][, options][, callback])

exécuter Un fichier

a fondamentalement la même fonction que exec. La différence est qu'il exécute un fichier de script avec un chemin donné et crée directement un nouveau processus au lieu de créer un environnement shell puis d'exécuter le script, ce qui est relativement. plus léger. Plus efficace. Cependant, sur les systèmes Windows, les fichiers tels que .cmd et .bat ne peuvent pas être exécutés directement. Cela signifie que execFile ne fonctionnera pas. Vous pouvez utiliser spawn et exec à la place.

fork

child_process.fork(modulePath[, args][, options])

Exécuter un fichier Node.js

// parent.js

const { fork } = require('child_process');

const child = fork('child.js');

child.on('message', (msg) => {
  console.log('Message from child', msg);
});

child.send({ hello: 'world' });

// child.js

process.on('message', (msg) => {
  console.log('Message from parent:', msg);
});

let counter = 0;

setInterval(() => {
  process.send({ counter: counter++ });
}, 3000);

fork est en fait une forme spéciale de spawn, qui corrige le processus spawn Node.js et l'établit entre le maître et processus enfants. Les canaux de communication permettent aux processus maîtres et enfants de communiquer en fonction des événements utilisant le module de processus.

Scénarios d'utilisation de sous-processus

1. Systèmes à forte intensité de calcul

2. Outils de création front-end utilisant plusieurs -CPU de base Calcul parallèle, améliore l'efficacité de la construction

3. Outils de gestion de processus, tels que : certaines fonctions de PM2

Ce qui précède est l'intégralité du contenu de cet article, j'espère qu'il sera utile à tout le monde. Apprendre est utile. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Introduction à la configuration de l'optimisation de Webpack pour affiner la portée de la recherche de fichiers

Le module Request dans Node. js gère HTTP Introduction à l'utilisation des requêtes de protocole

Analyse des types d'erreurs personnalisés sous Node.js

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!