Cluster机制剖析1——进程复制

转载自： http://luckydrq.com/2014-10-14/cluster-analyse-one/

Fork

fork()是类UNIX系统父进程复制子进程的系统调用，在Node里通过libuv实现了对不同平台(unix,linux,windows)的封装。引用百度百科的一段话来描述fork的特性：

fork之后的子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程间不共享这些存储空间。

其实，在node的cluster模式里，worker进程的产生也是调用了require('child_process').fork。

那直接这样不就行了？

1. var fork =require('child_process').fork;
2. var cpuNums =require('os').cpus().length;
3. var workerPath =require('path').join(__dirname,'worker.js');
5. for(var i =0; i < cpuNums; i++){
6. fork(workerPath,{ env: process.env });
7. }

这样的方式仅仅实现了多进程。多进程运行还涉及父子进程通信，子进程管理，以及负载均衡等问题，这些特性cluster帮你实现了，在后面的章节会一一道来。

两种逻辑

先看一个官网的例子：

1. var cluster =require('cluster');
2. var http =require('http');
3. var numCPUs =require('os').cpus().length;
5. if(cluster.isMaster){
6. // Fork workers.
7. for(var i =0; i < numCPUs; i++){
8. cluster.fork();
9. }
11. cluster.on('exit',function(worker, code, signal){
12. console.log('worker '+ worker.process.pid +' died');
13. });
14. }else{
15. // Workers can share any TCP connection
16. // In this case its a HTTP server
17. http.createServer(function(req, res){
18. res.writeHead(200);
19. res.end("hello world\n");
20. }).listen(8000);
21. }

以上代码的意思是：如果是父进程（Master），就复制多个子进程，子进程的数目等于CPU核心数。如果是子进程（Worker），就创建一个http服务器并监听8000端口。

我们在前面提到，子进程是父进程的“副本”，将得到父进程的数据（代码）空间及堆栈，因此，父子进程会执行同一段代码逻辑。这样就需要一种机制，能够在代码里区分当前进程是父进程还是子进程。首先来看看神秘的cluster模块究竟是什么：

1. // lib/cluster.js
3. functionCluster(){
4. EventEmitter.call(this);
5. }
7. util.inherits(Cluster,EventEmitter);
9. var cluster =module.exports =newCluster();

它是一个Object，通过继承EventEmitter，使它有了事件驱动机制。

1. // Define isWorker and isMaster
2. cluster.isWorker ='NODE_UNIQUE_ID'in process.env;
3. cluster.isMaster =! cluster.isWorker;

可以看到cluster下有两个flag来标识区分当前进程，依据是当前进程的环境变量（env）里是否包含NODE_UNIQUE_ID这个字段。为什么子进程的环境变量里有这个字段而父进程没有？

扫描二维码关注公众号，回复： 481889 查看本文章

我们知道，在复制子进程的时候实际上是调用了require('child_process').fork，看一下这个方法的用法：

1. child_process.fork(modulePath,[args],[options])
2. modulePath StringThemodule to run in the child
3. args ArrayList of string arguments
4. options Object
5. cwd StringCurrent working directory of the child process
6. env ObjectEnvironment key-value pairs
7. encoding String(Default:'utf8')
8. execPath StringExecutable used to create the child process
9. execArgv ArrayList of string arguments passed to the executable (Default: process.execArgv)
10. silent BooleanIftrue, stdin, stdout,and stderr of the child will be piped to the parent, otherwise they will be inherited from the parent, see the "pipe"and"inherit" options for spawn()'s stdio for more details (default is false)
11. Return: ChildProcess object

可以看到方法的第三个参数options是个对象，其中options.env可以设置子进程的环境变量，即process.env。因此，可以推测，应该是这里调用的时候，在env里面添加了NODE_UNIQUE_ID这个标识。接下来就来看下代码：

1. functionWorker(customEnv){
2. ...
3. // Create or get process
4. if(cluster.isMaster){
6. // Create env object
7. // first: copy and add id property
8. var envCopy = util._extend({}, env);
9. envCopy['NODE_UNIQUE_ID']=this.id;
10. // second: extend envCopy with the env argument
11. if(isObject(customEnv)){
12. envCopy = util._extend(envCopy, customEnv);
13. }
15. // fork worker
16. this.process = fork(settings.exec, settings.args,{
17. 'env': envCopy,
18. 'silent': settings.silent,
19. 'execArgv': settings.execArgv
20. });
21. }else{
22. this.process = process;
23. }
24. ...
25. }

以上代码段印证了之前的推测，就不再赘述了。

还有个细节需要注意：

1. // src/node.js
2. if(process.env.NODE_UNIQUE_ID){
3. var cluster =NativeModule.require('cluster');
4. cluster._setupWorker();
6. // Make sure it's not accidentally inherited by child processes.
7. delete process.env.NODE_UNIQUE_ID;
8. }

在Node进程启动的时候，子进程会执行以上代码，我们先不追究_setupWorker的细节。可以看到NODE_UNIQUE_ID从环境变量里剔除了，这使得子进程可以作为Master继续复制子进程。

进程复制

继续官网的示例，我们先看父进程的执行逻辑：

1. if(cluster.isMaster){
2. // Fork workers.
3. for(var i =0; i < numCPUs; i++){
4. cluster.fork();
5. }
7. cluster.on('exit',function(worker, code, signal){
8. console.log('worker '+ worker.process.pid +' died');
9. });
10. }

很明显，主要就是执行fork调用。那我们就来看看cluster.fork做了什么？

1. // Fork a new worker
2. cluster.fork =function(env){
3. // This can only be called from the master.
4. assert(cluster.isMaster);
6. // Make sure that the master has been initialized
7. cluster.setupMaster();
9. return(new cluster.Worker(env));
10. };

先setupMaster，再返回一个cluster.Worker实例。其实workder实例化的代码在前面已经贴过了，我们来个完整版：

1. // Create a worker object, that works both for master and worker
2. functionWorker(customEnv){
3. if(!(thisinstanceofWorker))returnnewWorker();
4. EventEmitter.call(this);
6. varself=this;
7. var env = process.env;
9. // Assign a unique id, default null
10. this.id = cluster.isMaster ?++ids : toDecInt(env.NODE_UNIQUE_ID);
12. // XXX: Legacy. Remove in 0.9
13. this.workerID =this.uniqueID =this.id;
15. // Assign state
16. this.state ='none';
18. // Create or get process
19. if(cluster.isMaster){
21. // Create env object
22. // first: copy and add id property
23. var envCopy = util._extend({}, env);
24. envCopy['NODE_UNIQUE_ID']=this.id;
25. // second: extend envCopy with the env argument
26. if(isObject(customEnv)){
27. envCopy = util._extend(envCopy, customEnv);
28. }
30. // fork worker
31. this.process = fork(settings.exec, settings.args,{
32. 'env': envCopy,
33. 'silent': settings.silent,
34. 'execArgv': settings.execArgv
35. });
36. }else{
37. this.process = process;
38. }
40. if(cluster.isMaster){
41. // Save worker in the cluster.workers array
42. cluster.workers[this.id]=this;
44. // Emit a fork event, on next tick
45. // There is no worker.fork event since this has no real purpose
46. process.nextTick(function(){
47. cluster.emit('fork',self);
48. });
49. }
51. // handle internalMessage, exit and disconnect event
52. this.process.on('internalMessage', handleMessage.bind(null,this));
53. this.process.once('exit',function(exitCode, signalCode){
54. prepareExit(self,'dead');
55. self.emit('exit', exitCode, signalCode);
56. cluster.emit('exit',self, exitCode, signalCode);
57. });
58. this.process.once('disconnect',function(){
59. prepareExit(self,'disconnected');
60. self.emit('disconnect');
61. cluster.emit('disconnect',self);
62. });
64. // relay message and error
65. this.process.on('message',this.emit.bind(this,'message'));
66. this.process.on('error',this.emit.bind(this,'error'));
68. }

每个worker分配了一个id，注册在cluster.workers里。父进程和子进程注册了一堆事件，这些事件涉及父子进程通讯，我们在下一篇文章里详细讨论。接下来，我们再看看setupMaster做了什么：

1. cluster.setupMaster =function(options){
2. // This can only be called from the master.
3. assert(cluster.isMaster);
5. // Don't allow this function to run more than once
6. if(masterStarted)return;
7. masterStarted =true;
9. // Get filename and arguments
10. options = options ||{};
12. // By default, V8 writes the profile data of all processes to a single
13. // v8.log.
14. //
15. // Running that log file through a tick processor produces bogus numbers
16. // because many events won't match up with the recorded memory mappings
17. // and you end up with graphs where 80+% of ticks is unaccounted for.
18. //
19. // Fixing the tick processor to deal with multi-process output is not very
20. // useful because the processes may be running wildly disparate workloads.
21. //
22. // That's why we fix up the command line arguments to include
23. // a "--logfile=v8-%p.log" argument (where %p is expanded to the PID)
24. // unless it already contains a --logfile argument.
25. var execArgv = options.execArgv || process.execArgv;
26. if(execArgv.some(function(s){return/^--prof/.test(s);})&&
27. !execArgv.some(function(s){return/^--logfile=/.test(s);}))
28. {
29. execArgv = execArgv.slice();
30. execArgv.push('--logfile=v8-%p.log');
31. }
33. // Set settings object
34. settings = cluster.settings ={
35. exec: options.exec|| process.argv[1],
36. execArgv: execArgv,
37. args: options.args || process.argv.slice(2),
38. silent: options.silent ||false
39. };
41. // emit setup event
42. cluster.emit('setup');
43. };

这里是复制子进程之前的一些准备工作。你可以显示调用这个方法并传入一些配置，主要就是指定子进程的执行入口options.exec，如果像官网例子那样不显式调用，则默认把当前文件作为入口。