Nodejs minimalist introductory tutorial (3): Process_node.js

Although Node has multiple threads, JavaScript running on v8 is single-threaded. Node's child_process module is used to create child processes, and we can make full use of the CPU through child processes. Example:

Copy code The code is as follows:

var fork = require('child_process').fork;
// Get the number of CPUs of the current machine
var cpus = require('os').cpus();
for (var i = 0; i < cpus.length; i ) {
// Generate new process
Fork('./worker.js');
}

Here are some process creation methods including fork:

1.spawn(command, [args], [options]), starts a new process to execute the command command, args is the command line parameter
2.exec(command, [options], callback), starts a new process to execute the command command, callback is used to obtain standard input, standard output, and error information when the process ends
3.execFile(file, [args], [options], [callback]), starts a new process to execute the executable file file, callback is used to obtain standard input, standard output, and error information when the process ends
4.fork(modulePath, [args], [options]), starts a new process to execute a JavaScript file module, and a Node child process is created at this time

Node inter-process communication

Parent Process

Copy code The code is as follows:

// parent.js
var fork = require('child_process').fork;
// fork returns the child process object n
var n = fork('./child.js');
// Handle event message
n.on('message', function(m) {
// Receive message sent by child process
console.log('got message: ' m);
});

//Send message to child process
n.send({hello: 'world'});

Child process

Copy code The code is as follows:

// child.js
// Handle event message
process.on('message', function(m) {
console.log('got message: ' m);
});

// There is a send method in process, which is used to send messages to the parent process
process.send({foo: 'bar'});

It should be noted that the send method here is synchronous, so it is not recommended to send large amounts of data (you can use pipe instead, see for details: http://nodejs.org/api/all. html#child_process_child_process_spawn_command_args_options).
In special cases, if the cmd attribute value in the message contains the NODE_ prefix (for example: {cmd: ‘NODE_foo’} message), then this message will not be submitted to the message event (but the internalMessage event), and they are used internally by Node.

The prototype of

send method is:

Copy code The code is as follows:

send(message, [sendHandle])

Here, sendHandle(handle) can be used to send:

1.net.Native, native C TCP socket or pipe
2.net.Server, TCP server
3.net.Socket, TCP socket
4.dgram.Native, native C UDP socket
5.dgram.Socket, UDP socket

When send sends sendHandle, it actually does not (and cannot) send JavaScript objects directly, but sends a file descriptor (eventually sent as a JSON string). Other processes can use this file descriptor to restore the corresponding object.

Now look at an example:

Parent Process

Copy code The code is as follows:

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

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

var server = require('net').createServer();
server.listen(7000, function() {
//Send TCP server to child process
n.send('server', server);
}).on('connection', function() {
console.log('connection - parent');
});

Child process

Copy code The code is as follows:

process.on('message', function(m, h) {
If (m === 'server') {
          h.on('connection', function() {
console.log('connection - child');
        });
}
});

Access this program through port 7000, and the output may be connection – parent or connection – child. Here the child process and the parent process are listening on port 7000 at the same time. Generally speaking, multiple processes listening to the same port will cause an EADDRINUSE exception. In this case, two different processes use the same file descriptor, and the bottom layer of Node sets the SO_REUSEADDR option on the socket when listening on the port. , which allows this socket to be reused among different processes. When multiple processes listen to the same port, the file descriptor can only be used by one process at the same time, and the use of sockets by these processes is preemptive.

cluster module

The cluster module was added in Node v0.8. Through the cluster module, you can easily build a group of processes listening to the same port on a physical machine. Example:

Copy code The code is as follows:

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

// Check whether the process is the master process
if (cluster.isMaster) {
for (var i = 0; i < numCPUs; i)
// Generate a new worker process (only the master process can be called)
        cluster.fork();

cluster.on('exit', function(worker, code, signal) {
console.log('worker ' worker.process.pid ' died');
});
} else {
http.createServer(function(req, res) {
           res.writeHead(200);
          res.end('hello worldn');
}).listen(8000);
}

We call the listen method in the worker process, and the listening request will be passed to the master process. If the master process already has a listening server that meets the requirements of the worker process, then the handle of this server will be passed to the worker. If it does not exist, the master process will create one and then pass the handle to the worker process.

More detailed documentation about cluster: http://www.nodejs.org/api/cluster.html