Node.Js中实现端口重用原理详解
本文介绍了Node.Js中实现端口重用原理详解，分享给大家，具体如下：
起源，从官方实例中看多进程共用端口
constcluster=require('cluster');
consthttp=require('http');
constnumCPUs=require('os').cpus().length;
if(cluster.isMaster){
console.log(`Master${process.pid}isrunning`);
for(leti=0;i{
console.log(`worker${worker.process.pid}died`);
});
}else{
http.createServer((req,res)=>{
res.writeHead(200);
res.end('helloworld\n');
}).listen(8000);
console.log(`Worker${process.pid}started`);
}
执行结果：
$nodeserver.js
Master3596isrunning
Worker4324started
Worker4520started
Worker6056started
Worker5644started
了解http.js模块：
我们都只有要创建一个http服务，必须引用http模块,http模块最终会调用net.js实现网络服务
//lib/net.js
'usestrict';
...
Server.prototype.listen=function(...args){
...
if(optionsinstanceofTCP){
this._handle=options;
this[async_id_symbol]=this._handle.getAsyncId();
listenInCluster(this,null,-1,-1,backlogFromArgs);//注意这个方法调用了cluster模式下的处理办法
returnthis;
}
...
};
functionlistenInCluster(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;
}
constserverQuery={
address:address,
port:port,
addressType:addressType,
fd:fd,
flags:0
};
//是fork出来的进程，获取master上的handel,并且监听，
//现在是不是很好奇_getServer方法做了什么
cluster._getServer(server,serverQuery,listenOnMasterHandle);
}
...
答案很快就可以通过cluster._getServer这个函数找到
- 代理了server._listen2这个方法在work进程的执行操作
- 向master发送queryServer消息，向master注册一个内部TCP服务器
//lib/internal/cluster/child.js
cluster._getServer=function(obj,options,cb){
//...
constmessage=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';
constaddress=obj.address();
message.act='listening';
message.port=address&&address.port||options.port;
send(message);
});
};
//...
//Round-robin.Masterdistributeshandlesacrossworkers.
functionrr(message,indexesKey,cb){
if(message.errno)returncb(message.errno,null);
varkey=message.key;
//这里hack了listen方法
//子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误
functionlisten(backlog){
return0;
}
//...
consthandle={close,listen,ref:noop,unref:noop};
handles[key]=handle;
//这个cb函数是net.js中的listenOnMasterHandle方法
cb(0,handle);
}
//lib/net.js
/*
functionlistenOnMasterHandle(err,handle){
err=checkBindError(err,port,handle);
server._handle=handle;
//_listen2函数中,调用的handle.listen方法，也就是上面被hack的listen
server._listen2(address,port,addressType,backlog,fd);
}
*/
master进程收到queryServer消息后进行启动服务
- 如果地址没被监听过，通过RoundRobinHandle监听开启服务
- 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求
//lib/internal/cluster/master.js
functionqueryServer(worker,message){
constargs=[
message.address,
message.port,
message.addressType,
message.fd,
message.index
];
constkey=args.join(':');
varhandle=handles[key];
//如果地址没被监听过，通过RoundRobinHandle监听开启服务
if(handle===undefined){
varconstructor=RoundRobinHandle;
if(schedulingPolicy!==SCHED_RR||
message.addressType==='udp4'||
message.addressType==='udp6'){
constructor=SharedHandle;
}
handles[key]=handle=newconstructor(key,
address,
message.port,
message.addressType,
message.fd,
message.flags);
}
//如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求
//Setcustomserverdata
handle.add(worker,(errno,reply,handle)=>{
reply=util._extend({
errno:errno,
key:key,
ack:message.seq,
data:handles[key].data
},reply);
if(errno)
deletehandles[key];//Givesotherworkersachancetoretry.
send(worker,reply,handle);
});
}
看到这一步，已经很明显，我们知道了多进行端口共享的实现原理
- 其实端口仅由master进程中的内部TCP服务器监听了一次
- 因为net.js模块中会判断当前的进程是master还是Worker进程
- 如果是Worker进程调用cluster._getServer去hack原生的listen方法
- 所以在child调用的listen方法，是一个return0的空方法，所以不会报端口占用错误
那现在问题来了，既然Worker进程是如何获取到master进程监听服务接收到的connect呢？
- 监听master进程启动的TCP服务器的connection事件
- 通过轮询挑选出一个worker
- 向其发送newconn内部消息，消息体中包含了客户端句柄
- 有了句柄，谁都知道要怎么处理了哈哈
//lib/internal/cluster/round_robin_handle.js
functionRoundRobinHandle(key,address,port,addressType,fd){
this.server=net.createServer(assert.fail);
if(fd>=0)
this.server.listen({fd});
elseif(port>=0)
this.server.listen(port,address);
else
this.server.listen(address);//UNIXsocketpath.
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);
constworker=this.free.shift();
if(worker)this.handoff(worker);
};
RoundRobinHandle.prototype.handoff=function(worker){
consthandle=this.handles.shift();
constmessage={act:'newconn',key:this.key};
//向work进程其发送newconn内部消息和客户端的句柄handle
sendHelper(worker.process,message,handle,(reply)=>{
//...
this.handoff(worker);
});
};
下面让我们看看Worker进程接收到newconn消息后进行了哪些操作
//lib/child.js
functiononmessage(message,handle){
if(message.act==='newconn')
onconnection(message,handle);
elseif(message.act==='disconnect')
_disconnect.call(worker,true);
}
//Round-robinconnection.
//接收连接，并且处理
functiononconnection(message,handle){
constkey=message.key;
constserver=handles[key];
constaccepted=server!==undefined;
send({ack:message.seq,accepted});
if(accepted)server.onconnection(0,handle);
}
总结
- net模块会对进程进行判断，是worker还是master,是worker的话进行hacknet.Server实例的listen方法
- worker调用的listen方法是hack掉的，直接return0,不过会向master注册一个connection接手的事件
- master收到客户端connection事件后，会轮询向worker发送connection上来的客户端句柄
- worker收到master发送过来客户端的句柄，这时候就可以处理客户端请求了
分享出于共享学习的目的，如有错误，欢迎大家留言指导，不喜勿喷。也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。