本文深入解析Node.js中Cluster模块实现多进程共享端口的底层原理。通过剖析net.js与cluster模块源码，揭示Master进程监听端口、Worker进程劫持listen方法以及通过内部消息传递客户端句柄的完整流程，阐明如何实现高性能的负载均衡。
本文详细解析Node.js中实现端口重用的核心原理，旨在帮助开发者深入理解多进程环境下的网络服务机制。
多进程共用端口的官方示例
首先，我们从官方提供的示例代码入手，观察多进程如何共用同一个端口。
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`Master ${process.pid} is running`);
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('exit', (worker, code, signal) => {
console.log(`worker ${worker.process.pid} died`);
});
} else {
http.createServer((req, res) => {
res.writeHead(200);
res.end('hello world\n');
}).listen(8000);
console.log(`Worker ${process.pid} started`);
}
运行该示例后的输出结果如下：
$ node server.js Master 3596 is running Worker 4324 started Worker 4520 started Worker 6056 started Worker 5644 started
为了理解其背后的实现，我们需要深入分析http模块的工作机制。
在Node.js中，创建HTTP服务必须引用http模块，而该模块底层最终依赖于net.js模块来实现具体的网络通信服务。
// lib/net.js
'use strict';
...
Server.prototype.listen = function(...args) {
...
if (options instanceof TCP) {
this._handle = options;
this[async_id_symbol] = this._handle.getAsyncId();
listenInCluster(this, null, -1, -1, backlogFromArgs); // 注意这个方法调用了cluster模式下的处理办法
return this;
}
...
};
function listenInCluster(server, address, port, addressType,backlog, fd, exclusive) {
// 如果是master 进程或者没有开启cluster模式直接启动listen
if (cluster.isMaster || exclusive) {
//_listen2,细心的人一定会发现为什么是listen2而不直接使用listen
// _listen2 包裹了listen方法，如果是Worker进程，会调用被hack后的listen方法，从而避免出错端口被占用的错误
server._listen2(address, port, addressType, backlog, fd);
return;
}
const serverQuery = {
address: address,
port: port,
addressType: addressType,
fd: fd,
flags: 0
};
// 是fork 出来的进程，获取master上的handel,并且监听，
// 现在是不是很好奇_getServer方法做了什么
cluster._getServer(server, serverQuery, listenOnMasterHandle);
}
...核心原理：Master与Worker的协作机制
端口共享的关键逻辑隐藏在cluster._getServer函数中。
- 该函数在Worker进程中代理了server._listen2方法，从而改变了原有的监听行为。
- 具体而言，Worker进程会向Master进程发送名为queryServer的消息，以此在Master端注册一个内部的TCP服务器。
// lib/internal/cluster/child.js
cluster._getServer = function(obj, options, cb) {
// ...
const message = util._extend({
act: 'queryServer', // 关键点：构建一个queryServer的消息
index: indexes[indexesKey],
data: null
}, options);
message.address = address;
// 发送queryServer消息给master进程，master 在收到这个消息后，会创建一个开始一个server，并且listen
send(message, (reply, handle) => {
rr(reply, indexesKey, cb); // Round-robin.
});
obj.once('listening', () => {
cluster.worker.state = 'listening';
const address = obj.address();
message.act = 'listening';
message.port = address && address.port || options.port;
send(message);
});
};
//...
// Round-robin. Master distributes handles across workers.
function rr(message, indexesKey, cb) {
if (message.errno) return cb(message.errno, null);
var key = message.key;
// 这里hack 了listen方法
// 子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误
function listen(backlog) {
return 0;
}
// ...
const handle = { close, listen, ref: noop, unref: noop };
handles[key] = handle;
// 这个cb 函数是net.js 中的listenOnMasterHandle 方法
cb(0, handle);
}
// lib/net.js
/*
function listenOnMasterHandle(err, handle) {
err = checkBindError(err, port, handle);
server._handle = handle;
// _listen2 函数中,调用的handle.listen方法，也就是上面被hack的listen
server._listen2(address, port, addressType, backlog, fd);
}
*/
当Master进程接收到queryServer消息后，便会启动相应的服务监听逻辑。
- 如果该地址尚未被监听，Master进程会通过RoundRobinHandle来开启服务监听。
- 若该地址已被监听，Master进程则直接将句柄绑定到已存在的服务上，由Worker进程去消费接收到的请求。
// lib/internal/cluster/master.js
function queryServer(worker, message) {
const args = [
message.address,
message.port,
message.addressType,
message.fd,
message.index
];
const key = args.join(':');
var handle = handles[key];
// 如果地址没被监听过，通过RoundRobinHandle监听开启服务
if (handle === undefined) {
var constructor = RoundRobinHandle;
if (schedulingPolicy !== SCHED_RR ||
message.addressType === 'udp4' ||
message.addressType === 'udp6') {
constructor = SharedHandle;
}
handles[key] = handle = new constructor(key,
address,
message.port,
message.addressType,
message.fd,
message.flags);
}
// 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求
// Set custom server data
handle.add(worker, (errno, reply, handle) => {
reply = util._extend({
errno: errno,
key: key,
ack: message.seq,
data: handles[key].data
}, reply);
if (errno)
delete handles[key]; // Gives other workers a chance to retry.
send(worker, reply, handle);
});
}
至此，多进程共享端口的实现原理已清晰可见：
- 实际上，端口仅在Master进程中的内部TCP服务器处被监听了一次。
- 这是因为net.js模块在代码中判断了当前进程是Master还是Worker。
- 如果是Worker进程，它会调用cluster._getServer来“劫持”原生的listen方法。
- 因此，Worker进程中调用的listen方法实际上是一个返回0的空操作，这避免了端口占用报错。
连接句柄的传递与处理流程
接下来探讨核心问题：Worker进程如何获取Master进程监听服务时接收到的连接？
- Worker进程会监听由Master启动的TCP服务器的connection事件。
- Master进程通过轮询算法挑选出一个合适的Worker。
- 随后，Master向该Worker发送名为newconn的内部消息，消息体中包含了客户端的句柄。
- 一旦Worker获得了客户端句柄，即可直接处理后续的网络请求。
// lib/internal/cluster/round_robin_handle.js
function RoundRobinHandle(key, address, port, addressType, fd) {
this.server = net.createServer(assert.fail);
if (fd >= 0)
this.server.listen({ fd });
else if (port >= 0)
this.server.listen(port, address);
else
this.server.listen(address); // UNIX socket path.
this.server.once('listening', () => {
this.handle = this.server._handle;
// 监听onconnection方法
this.handle.onconnection = (err, handle) => this.distribute(err, handle);
this.server._handle = null;
this.server = null;
});
}
RoundRobinHandle.prototype.add = function (worker, send) {
// ...
};
RoundRobinHandle.prototype.remove = function (worker) {
// ...
};
RoundRobinHandle.prototype.distribute = function (err, handle) {
// 负载均衡地挑选出一个worker
this.handles.push(handle);
const worker = this.free.shift();
if (worker) this.handoff(worker);
};
RoundRobinHandle.prototype.handoff = function (worker) {
const handle = this.handles.shift();
const message = { act: 'newconn', key: this.key };
// 向work进程其发送newconn内部消息和客户端的句柄handle
sendHelper(worker.process, message, handle, (reply) => {
// ...
this.handoff(worker);
});
};
下面我们将具体查看Worker进程在接收到newconn消息后执行的操作流程。
// lib/child.js
function onmessage(message, handle) {
if (message.act === 'newconn')
onconnection(message, handle);
else if (message.act === 'disconnect')
_disconnect.call(worker, true);
}
// Round-robin connection.
// 接收连接，并且处理
function onconnection(message, handle) {
const key = message.key;
const server = handles[key];
const accepted = server !== undefined;
send({ ack: message.seq, accepted });
if (accepted) server.onconnection(0, handle);
}
端口复用机制总结
综上所述，Node.js多进程端口复用的核心机制如下：
- net模块首先判断进程角色，若为Worker，则对net.Server实例的listen方法进行劫持。
- Worker调用的listen方法经过劫持后直接返回0，但会向Master注册一个connection事件处理程序。
- 当Master收到客户端的connection事件后，会通过轮询方式向Worker发送包含客户端句柄的连接信息。
- Worker接收到Master发送的客户端句柄后，即可正常处理客户端的请求。
本文分享旨在促进技术交流与共享，如有疏漏或错误，欢迎指正，不喜勿喷。也希望大家多多支持本站。