Node.js
multithreading
Zoeken…
Invoering
Node.js is ontworpen als enkelschroefdraad. Dus voor alle praktische doeleinden kunnen applicaties die met Node worden gestart, op één thread worden uitgevoerd.
Node.js draait echter zelf multi-threaded. I / O-bewerkingen en dergelijke worden uitgevoerd vanuit een threadpool. Verder zal elk exemplaar van een knooppunttoepassing op een andere thread draaien, dus om applicaties met meerdere threads te draaien, start men meerdere instanties.
Opmerkingen
Inzicht in de Event Loop is belangrijk om te begrijpen hoe en waarom meerdere threads moeten worden gebruikt.
TROS
Met de cluster kunt u dezelfde applicatie meerdere keren starten.
Clustering is wenselijk wanneer de verschillende instanties dezelfde uitvoeringsstroom hebben en niet van elkaar afhankelijk zijn. In dit scenario hebt u één master die vorken en de vorken (of kinderen) kan starten. De kinderen werken zelfstandig en hebben hun enige ruimte voor Ram en Event Loop.
Het opzetten van clusters kan voordelig zijn voor websites / API's. Elke thread kan elke klant bedienen, omdat deze niet afhankelijk is van andere threads. Een database (zoals Redis) zou worden gebruikt om cookies te delen, aangezien variabelen niet kunnen worden gedeeld! tussen de draden.
// runs in each instance
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;
console.log('I am always called');
if (cluster.isMaster) {
// runs only once (within the master);
console.log('I am the master, launching workers!');
for(var i = 0; i < numCPUs; i++) cluster.fork();
} else {
// runs in each fork
console.log('I am a fork!');
// here one could start, as an example, a web server
}
console.log('I am always called as well');
Kindproces
Kindprocessen zijn de beste keuze wanneer u processen onafhankelijk wilt uitvoeren met verschillende initialisatie en problemen. Net als vorken in clusters, draait een child_process in zijn thread, maar in tegenstelling tot vorken, heeft het een manier om te communiceren met zijn ouder.
De communicatie verloopt beide kanten op, zodat ouder en kind naar berichten kunnen luisteren en berichten kunnen verzenden.
Ouder (../parent.js)
var child_process = require('child_process');
console.log('[Parent]', 'initalize');
var child1 = child_process.fork(__dirname + '/child');
child1.on('message', function(msg) {
console.log('[Parent]', 'Answer from child: ', msg);
});
// one can send as many messages as one want
child1.send('Hello'); // Hello to you too :)
child1.send('Hello'); // Hello to you too :)
// one can also have multiple children
var child2 = child_process.fork(__dirname + '/child');
Kind (../child.js)
// here would one initialize this child
// this will be executed only once
console.log('[Child]', 'initalize');
// here one listens for new tasks from the parent
process.on('message', function(messageFromParent) {
//do some intense work here
console.log('[Child]', 'Child doing some intense work');
if(messageFromParent == 'Hello') process.send('Hello to you too :)');
else process.send('what?');
})
Naast het bericht kan men luisteren naar vele gebeurtenissen zoals 'error', 'connected' of 'disconnect'.
Aan het starten van een kindproces zijn bepaalde kosten verbonden. Je zou er zo weinig mogelijk willen spawnen.
