Le nœud a plusieurs threads, mais JavaScript en cours d'exécution sur V8 est unique. Le module Child_Process de Node est utilisé pour créer des processus enfants, et nous pouvons utiliser pleinement le CPU via les processus enfants. exemple:
La copie de code est la suivante:
var fork = require ('child_process'). Fork;
// Obtenez le numéro de CPU de la machine actuelle
var cpus = require ('os'). CPU ();
pour (var i = 0; i <cpus.length; i ++) {
// générer un nouveau processus
fork ('./ worker.js');
}
Voici quelques façons de créer des processus, y compris la fourche:
1.Spawn (commande, [args], [options]), démarrez un nouveau processus pour exécuter la commande de commande, args est un paramètre de ligne de commande
2.Exec (commande, [Options], rappel), démarrez un nouveau processus pour exécuter la commande de commande, le rappel est utilisé pour obtenir des entrées standard, une sortie standard et des informations d'erreur à la fin du processus.
3.ExecFile (fichier, [args], [options], [rappel]), démarre un nouveau processus pour exécuter le fichier exécutable. Le rappel est utilisé pour obtenir des informations sur les entrées standard, la sortie standard et les erreurs à la fin du processus.
4.Fork (modulepath, [args], [options]), démarrez un nouveau processus pour exécuter un module de fichier JavaScript et le processus d'enfant nœud est créé pour le moment.
Communication d'interprocess nœud
Processus parental
La copie de code est la suivante:
// parent.js
var fork = require ('child_process'). Fork;
// fourche renvoie l'objet de processus enfant n
var n = fourk ('./ child.js');
// gérer le message de l'événement
n.on ('message', fonction (m) {
// reçoit un message envoyé par le processus de l'enfant
Console.log ('Got Message:' + M);
});
// Envoyez un message au processus de l'enfant
N.Send ({Hello: 'World'});
Sous-processus
La copie de code est la suivante:
// child.js
// gérer le message de l'événement
process.on ('message', fonction (m) {
Console.log ('Got Message:' + M);
});
// La méthode d'envoi existe 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 http://nodejs.org/api/all.html#child_process_child_process_spawn_command_args_options pour plus de détails).
Dans des cas spéciaux, la valeur d'attribut CMD dans le message contient le préfixe Node_ (par exemple: {CMD: 'Node_foo'}), alors ce message ne sera pas soumis à l'événement de message (mais l'événement InternalMessage), et ils sont utilisés en interne par nœud.
Le prototype de la méthode d'envoi est:
La copie de code est la suivante:
Envoyer (message, [SendHandle])
Ici, SendHandle (Handle) peut être utilisé pour envoyer:
1.Net.Native, socket ou pipeline C ++ natif
2.Net.Server, serveur TCP
3.Net.Socket, socket TCP
4.dgram.Native, socket UDP C ++ natif
5.dgram.socket, socket udp
Envoyer lors de l'envoi SendHandle, il n'est pas (et ne peut pas) d'envoyer directement des objets JavaScript, mais d'envoyer un descripteur de fichier (finalement envoyé en tant que chaîne JSON). D'autres processus peuvent restaurer l'objet correspondant via ce descripteur de fichier.
Regardez maintenant un exemple:
Processus parental
La copie de code est la suivante:
// parent.js
var fork = require ('child_process'). Fork;
var n = fourk ('./ child.js');
var server = require ('net'). CreateServer ();
server.Listen (7000, function () {
// Envoie le serveur TCP au processus enfant
n.send ('serveur', serveur);
}). sur ('connexion', fonction () {
console.log ('connexion - parent');
});
Sous-processus
La copie de code est la suivante:
process.on ('message', fonction (m, h) {
if (m === 'server') {
h.on ('connexion', function () {
console.log ('connexion - enfant');
});
}
});
L'accès à ce programme via le port 7000 peut entraîner la sortie en tant que parent de connexion ou enfant de connexion. Ici, le processus de l'enfant et le processus parent écoutent le port 7000 en même temps. D'une manière générale, plusieurs processus écoutant le même port entraîneront une exception EaddrinUse. Dans ce cas, deux processus différents utilisent le même descripteur de fichiers et le nœud sous-jacent des calques définit l'option SO_REUSEADDR sur la prise lors de l'écoute du port, ce qui permet à cette prise d'être réutilisée 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 en même temps, et ces processus utilisent des sockets de manière préventive.
module de cluster
Un nouveau module de cluster a été ajouté à V0.8 dans le nœud, à travers lequel le module de cluster peut facilement construire un groupe de processus écoutant le même port sur une machine physique. exemple:
La copie de code est la suivante:
var cluster = require ('cluster');
var http = require ('http');
var numcpus = require ('os'). CPU (). Longueur;
// Vérifiez si le processus est un processus maître
if (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', fonction (travailleur, code, signal) {
Console.log ('Worker' + Worker.Process.pid + 'Die');
});
} autre {
http.createServer (fonction (req, res) {
res.writehead (200);
res.end ('Hello World / N');
}). écouter (8000);
}
Nous appelons la méthode d'écoute dans le processus des travailleurs, et la demande d'écoute sera transmise au processus maître. Si le processus maître a déjà un serveur écoutant pour répondre aux exigences du processus du travailleur, la poignée de ce serveur sera transmise au travailleur. S'il n'existe pas, le processus de maître en créera un, puis transmettra la poignée au processus du travailleur.
Documentation plus détaillée sur le cluster: http://www.nodejs.org/api/cluster.html