node集群搭建好之后，还需要考虑一些细节问题。
- 性能问题
- 多个工作进程的存活状态管理
- 工作进程的平滑重启
- 配置或者静态数据的动态重新载入
- 其它细节
1 进程事件
Node子进程对象除了send()方法和messge事件外，还有如下事件：
- error： 当子进程无法被复制创建、无法被杀死、无法发送消息时会触发改事件。
- exit：子进程退出时触发改事件，子进程如果是正常退出，这个事件的第一个参数为退出码，否则为null。如果进程是通过kill方法被杀死的，会得到第二个参数，它表示杀死进程时
的信号。 - close：在子进程的标准输入输出流中止时触发该事件，参数与exit相同。
- disconnect：在父进程或子进程中调用disconnect()方法时触发该事件，在调用该方法时将关闭监听IPC通道。
上述这些事件是在父进程能监听到的与子进程相关的事件。除了send()外，还能通过kill()方法给子进程发送消息。kill()方法并不能真正的将通过IPC相连的子进程杀死，它只是给子进程发送
了一个系统信号。默认情况下，父进程将通过kill()方法给子进程发送一个SIGTERM信号。它与进程默认的kill()方法类似。
// 子进程
child.kill([signal]); // 当前进程
process.kill(pid, [signal]);
2 自动重启
有了父子进程之间的相关事件后，就可以在这些关系之间创建出需要的机机制了。监听子进程的exit事件来获知其退出的信息，并在主进程中加入一些子进程管理的机制，比如重新启用一个
新的工作进程来继续服务。
实现代码如下所示：
master.js
var fork = require('child_process').fork;
var cpus = require('os').cpus();
var server = require('net').createServer();
server.listen(1337, () => {
console.log('server listen at port 1337');
})
var workers = {};
var createWorker = function() {
var worker = fork(__dirname + '/worker.js');
// 退出时重新启动新的进程
worker.on('exit', () => {
console.log('Worker ' + worker.pid + ' exited');
delete workers[worker.pid];
createWorker();
})
// 句柄转发
worker.send('server', server);
workers[worker.pid] = worker;
console.log('Create worker. pid: ' + worker.pid);
}
for (var i = 0; i < cpus.length; i++) {
createWorker();
}
// 进程自己退出时，让所有工作进程退出
process.on('exit', () => {
for (var pid in workers) {
workers[pid].kill();
}
})
worker.js
var http = require('http');
var server = http.createServer((req, res) => {
res.writeHead(200, {
'Content-Type': 'text/plain'
});
res.end('handled by child, pid is ' + process.pid + '\n');
});
var worker;
process.on('message', (m, tcp) => {
if (m === 'server') {
worker = tcp;
worker.on('connection', (socket) => {
server.emit('connection', socket);
})
}
})
process.on('uncaughtException', () => {
// 停止接受新的连接
worker.close(() => {
//所有已有的链接断开后，退出进程
process.exit(1);
});
})
上述代码的处理流程是，一旦有未捕获的异常出现，工作进程就会立即停止接收新的连接；当所有连接断开后，退出进程。主进程在侦听到工作进程的exit后，将会立即启动新的进程服务，以此
保证整个集群中总是有进程在为用户服务的。
2.1 自杀信号
上述代码存在的问题是要等到所有连接断开后进程才退出，在极端情况下，所有工作进程都停止接收新的连接，全处在等待退出的状态。但在等到进程完全退出才重启的过程中，所有新来的请求
可能存在没有工作进程为新用户服务的情景，这会丢掉大部分请求。
为此需要改进这个过程，不能等到工作进程退出后才重启新的工作进程。当然也不能暴力退出进程，因为这样会导致已连接的用户直接断开。于是在退出的流程中增加一个自杀连接，当所有的连接断开后才退出。主进程在接收到自杀信号后，立即创建新的工作进程服务。代码改动如下：
// worker.js
process.on('uncaughtException', () => {
process.send({act: 'suicide'});
// 停止接受新的连接
worker.close(() => {
//所有已有的链接断开后，退出进程
process.exit(1);
});
}) // master.js
var createWorker = function() {
var worker = fork(__dirname + '/worker.js');
// 启动新的进程
worker.on('message', (message) => {
if (message.act === 'suicide') {
createWorker();
}
});
// 退出时重新启动新的进程
worker.on('exit', () => {
console.log('Worker ' + worker.pid + ' exited');
delete workers[worker.pid];
})
// 句柄转发
worker.send('server', server);
workers[worker.pid] = worker;
console.log('Create worker. pid: ' + worker.pid);
}
至此我们完成了进程的平滑重启，一旦有异常出现，主进程就会创建新的工作进程来为用户服务，旧的进程一旦处理完了已有连接就自动断开。整个过程使得我们的应用稳定性和健壮性大大提高。
这里存在问题的是有可能我们的连接是长连接，不是HTTP服务的这种短连接，等待长时间断开可能需要较久的时间。为此为已有连接的断开设置一个超时时间是必要的，在限定时间里强制退出。
// worker.js
process.on('uncaughtException', () => {
process.send({act: 'suicide'});
// 停止接受新的连接
worker.close(() => {
//所有已有的链接断开后，退出进程
process.exit(1);
});
// 5秒后退出
setTimeout(() => {
process.exit(1);
}, 5000)
})
进程中如果出现未能捕获的异常，就意味着有那么一段代码在健壮性上是不合格的。为此退出进程前，通过日志记录下问题所在是必须要做的事情，它可以帮我们很好地定位和追踪代码异常出现的位置，如下所示：
process.on('uncaughtException', (err) => {
// 记录日志
logger.error(err);
process.send({act: 'suicide'});
// 停止接受新的连接
worker.close(() => {
//所有已有的链接断开后，退出进程
process.exit(1);
});
// 5秒后退出
setTimeout(() => {
process.exit(1);
}, 5000)
})
2.2 限量重启
通过自杀信号告知主进程可以使得新连接总是有进程服务，但是依然还是有极端的情况。工作进程不能无限制的被重启，如果启动的过程中就发生了错误，或者启动后接到连接就收到错误，
会导致工作进程被频繁重启，这种频繁重启不属于我们捕捉未知异常的情况，因为这种短时间内频繁重启已经不符合预期的设置，极有可能是程序编写的错误。
为了消除这种无意义的重启，在满足一定规则的限制下，不应当反复重启。比如在单位时间内规定只能重启多少次，超过限制就触发giveup事件，告知放弃重启工作进程这个重要事情。
为了完成限量重启的统计，引入一个队列来做标记，在每次重启工作进程之间进行打点并判断重启是否太过频繁，如下所示：
var fork = require('child_process').fork;
var cpus = require('os').cpus();
var server = require('net').createServer();
server.listen(1337, () => {
console.log('server listen at port 1337');
})
// 重启次数
var limit = 10;
// 时间单位
var during = 60000;
var restart = [];
var isTooFrequently = function() {
// 记录重启时间
var time = Date.now();
var length = restart.push(time);
if (length > limit) {
// 取出最后10个记录
restart = restart.slice(limit * -1);
}
//最后一次重启到前10次重启之间的时间间隔
return restart.length >= limit && restart[restart.length - 1] - restart[0] < during;
}
var workers = {};
var createWorker = function() {
// 检查是否太过频繁
if (isTooFrequently()) {
// 触发giveup事件后，不再重启
process.emit('giveip', length, during);
return;
}
var worker = fork(__dirname + '/worker.js');
// 启动新的进程
worker.on('message', (message) => {
if (message.act === 'suicide') {
createWorker();
}
});
// 退出时重新启动新的进程
worker.on('exit', () => {
console.log('Worker ' + worker.pid + ' exited');
delete workers[worker.pid];
})
// 句柄转发
worker.send('server', server);
workers[worker.pid] = worker;
console.log('Create worker. pid: ' + worker.pid);
}
for (var i = 0; i < cpus.length; i++) {
createWorker();
}
// 进程自己退出时，让所有工作进程退出
process.on('exit', () => {
for (var pid in workers) {
workers[pid].kill();
}
})
giveup事件是比uncaughtException更严重的异常事件。uncaughtException只代表集群中某个工作进程退出，在整体性保证下，不会出现用户得不到服务的情况，但是这个giveup事件则表示
集群中没有任何进程服务了，十分危险。为了健壮性了考虑，我们应在giveup事件中添加重要日志，并让监控系统监视到这个严重错误，进而报警等。
3 负载均衡
在多进程之间监听相同的接口，使得请求能够分散到多个进程上进行处理，这带来的好处是可以将CPU资源都调用起来。Node默认提供的机制是采用操作系统的抢占式策略。所谓的抢占式就是
在一堆工作进程中，闲着的进程对到来的请求进行争抢，谁抢到谁服务。
一般而言，这种抢占式策略对大家是公平的，各个进程可以根据自己的繁忙度来进行抢占。但是对于node而言，需要分清的是它的繁忙是有CPU、I/O两个部分构成的，影响抢占的是CPU的繁忙度。对于不同的业务，可能存在I/O繁忙，而CPU较为空闲的情况，这可能造成某个进程能够抢到较多请求，形成负载不均衡的情况。
为此Node在v0.11中提供了一种新的策略使得负载均衡更合理，这种新的策略叫Round-Robin,又叫轮叫调度。轮叫调度的工作方式是由主进程接受连接，将其一次分发给工作进程。分发的策略
是在N个工作进程中，每次选择第i = ( i + 1 ) mod n个进程来发送连接。
Round-Robin非常简单，可以避免CPU和I/O繁忙差异导致的负载不均衡。Round-Robin策略也可以通过代理服务来实现，但是它会导致服务器上消耗的文件描述符是平常方式的两倍。