Tutoriel d'introduction minimaliste Nodejs (3) : Process_node.js

Bien que Node ait plusieurs threads, JavaScript exécuté sur la v8 est monothread. Le module child_process de Node est utilisé pour créer des processus enfants, et nous pouvons utiliser pleinement le processeur via les processus enfants. Exemple :

Copier le code Le code est le suivant :

var fork = require('child_process').fork;
// Récupère le nombre de CPU de la machine actuelle
var cpus = require('os').cpus();
pour (var i = 0; i < cpus.length; i ) {
// Générer un nouveau processus
Fourche('./worker.js');
>

Voici quelques méthodes de création de processus, y compris fork :

1.spawn(command, [args], [options]), démarre un nouveau processus pour exécuter la commande command, args est le paramètre de ligne de commande
2.exec(commande, [options], rappel), démarre un nouveau processus pour exécuter la commande commande, le rappel est utilisé pour obtenir l'entrée standard, la sortie standard et les informations d'erreur à la fin du processus
3.execFile(file, [args], [options], [callback]), démarre un nouveau processus pour exécuter le fichier exécutable, le rappel est utilisé pour obtenir l'entrée standard, la sortie standard et les informations d'erreur à la fin du processus
4.fork(modulePath, [args], [options]), démarre un nouveau processus pour exécuter un module de fichier JavaScript, et un processus enfant Node est créé à ce moment

Communication inter-processus des nœuds

Processus parent

Copier le code Le code est le suivant :

// parent.js
var fork = require('child_process').fork;
// fork renvoie l'objet processus enfant n
var n = fork('./child.js');
// Gérer le message d'événement
n.on('message', fonction(m) {
// Recevoir le message envoyé par le processus enfant
console.log('j'ai reçu un message : 'm);
});

//Envoyer un message au processus enfant
n.send({bonjour : 'monde'});

Processus enfant

Copier le code Le code est le suivant :

// enfant.js
// Gérer le message d'événement
process.on('message', function(m) {
console.log('j'ai reçu un message : 'm);
});

// Il existe une méthode d'envoi en cours, qui est utilisée pour envoyer des messages au processus parent
process.send({foo: 'bar'});

Il convient de noter que la méthode d'envoi ici est synchrone, il n'est donc pas recommandé d'envoyer de grandes quantités de données (vous pouvez utiliser pipe à la place, voir pour plus de détails : http://nodejs.org/api/ tout.html#child_process_child_process_spawn_command_args_options).
Dans des cas particuliers, si la valeur de l'attribut cmd dans le message contient le préfixe NODE_ (par exemple : message {cmd : 'NODE_foo'}), alors ce message ne sera pas soumis à l'événement message (mais à l'événement internalMessage), et ils sont utilisés en interne par Node.

Le prototype de la méthode

send est :

Copier le code Le code est le suivant :

envoyer(message, [sendHandle])

Ici, sendHandle(handle) peut être utilisé pour envoyer :

1.net.Native, socket ou canal C TCP natif
2.net.Serveur, serveur TCP
3.net.Socket, socket TCP
4.dgram.Native, socket C UDP natif
5.dgram.Socket, socket UDP

Lorsque send envoie sendHandle, il n'envoie pas (et ne peut pas) envoyer d'objets JavaScript directement, mais envoie un descripteur de fichier (éventuellement envoyé sous forme de chaîne JSON). D'autres processus peuvent utiliser ce descripteur de fichier pour restaurer l'objet correspondant.

Regardons maintenant un exemple :

Processus parent

Copier le code Le code est le suivant :

// parent.js
var fork = require('child_process').fork;

var n = fork('./child.js');

var serveur = require('net').createServer();
serveur.écouter (7000, fonction() {
//Envoyer le serveur TCP au processus enfant
n.send('serveur', serveur);
}).on('connexion', function() {
console.log('connexion - parent');
});

Processus enfant

Copier le code Le code est le suivant :

process.on('message', function(m, h) {
Si (m === 'serveur') {
          h.on('connexion', function() {
console.log('connexion - enfant');
});
>
});

Accédez à ce programme via le port 7000, et la sortie peut être connexion – parent ou connexion – enfant. Ici, le processus enfant et le processus parent écoutent sur le port 7000 en même temps. De manière générale, plusieurs processus écoutant le même port provoqueront une exception EADDRINUSE. Dans ce cas, deux processus différents utilisent le même descripteur de fichier et la couche inférieure de Node définit l'option SO_REUSEADDR sur le socket lors de l'écoute sur le port. permet à ce socket d'être réutilisé entre différents processus. Lorsque plusieurs processus écoutent le même port, le descripteur de fichier ne peut être utilisé que par un seul processus à la fois et l'utilisation des sockets par ces processus est préemptive.

module cluster

Le module cluster a été ajouté dans Node v0.8. Grâce au module cluster, vous pouvez facilement créer un groupe de processus écoutant le même port sur une machine physique. Exemple :

Copier le code Le code est le suivant :

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;

// Vérifiez si le processus est le processus maître
si (cluster.isMaster) {
pour (var i = 0; i < numCPUs; i)
// Générer un nouveau processus de travail (seul le processus maître peut être appelé)
        cluster.fork();

cluster.on('exit', function(worker, code, signal) {
console.log('worker ' worker.process.pid ' est mort');
});
} autre {
http.createServer(function(req, res) {
           res.writeHead(200);
          res.end('hello worldn');
}).écouter(8000);
>

Nous appelons la méthode d'écoute dans le processus de travail, et la demande d'écoute sera transmise au processus maître. Si le processus maître dispose déjà d'un serveur d'écoute qui répond aux exigences du processus de travail, alors le handle de ce serveur sera transmis au travailleur. S'il n'existe pas, le processus maître en créera un puis transmettra le handle au processus maître. processus de travail.

Documentation plus détaillée sur le cluster : http://www.nodejs.org/api/cluster.html