当前位置：Gxlcms > JavaScript > Node.Js中怎样实现端口重用功能

Node.Js中怎样实现端口重用功能

时间：2021-07-01 10:21:17 帮助过：46人阅读

这次给大家带来Node.Js中怎样实现端口重用功能，Node.Js中实现端口重用功能的注意事项有哪些，下面就是实战案例，一起来看一下。

起源，从官方实例中看多进程共用端口

  1. const cluster = require('cluster');
  2. const http = require('http');
  3. const numCPUs = require('os').cpus().length;
  4. if (cluster.isMaster) {
  5.  console.log(`Master ${process.pid} is running`);
  6.  for (let i = 0; i < numCPUs; i++) {
  7.   cluster.fork();
  8.  }
  9.  cluster.on('exit', (worker, code, signal) => {
  10.   console.log(`worker ${worker.process.pid} died`);
  11.  });
  12. } else {
  13.  http.createServer((req, res) => {
  14.   res.writeHead(200);
  15.   res.end('hello world\n');
  16.  }).listen(8000);
  17.  console.log(`Worker ${process.pid} started`);
  18. }

执行结果：

$ node server.js
Master 3596 is running
Worker 4324 started
Worker 4520 started
Worker 6056 started
Worker 5644 started

了解http.js模块：

我们都只有要创建一个http服务，必须引用http模块,http模块最终会调用net.js实现网络服务

  1. // lib/net.js
  2. 'use strict';
  3.  ...
  4. Server.prototype.listen = function(...args) {
  5.   ...
  6.  if (options instanceof TCP) {
  7.    this._handle = options;
  8.    this[async_id_symbol] = this._handle.getAsyncId();
  9.    listenInCluster(this, null, -1, -1, backlogFromArgs); // 注意这个方法调用了cluster模式下的处理办法
  10.    return this;
  11.   }
  12.   ...
  13. };
  14. function listenInCluster(server, address, port, addressType,backlog, fd, exclusive) {
  15. // 如果是master 进程或者没有开启cluster模式直接启动listen
  16. if (cluster.isMaster || exclusive) {
  17.   //_listen2,细心的人一定会发现为什么是listen2而不直接使用listen
  18.  // _listen2 包裹了listen方法，如果是Worker进程，会调用被hack后的listen方法，从而避免出错端口被占用的错误
  19.   server._listen2(address, port, addressType, backlog, fd);
  20.   return;
  21.  }
  22.  const serverQuery = {
  23.   address: address,
  24.   port: port,
  25.   addressType: addressType,
  26.   fd: fd,
  27.   flags: 0
  28.  };
  29. // 是fork 出来的进程，获取master上的handel,并且监听，
  30. // 现在是不是很好奇_getServer方法做了什么
  31.  cluster._getServer(server, serverQuery, listenOnMasterHandle);
  32. }
  33.  ...

答案很快就可以通过cluster._getServer 这个函数找到

  1. 代理了server._listen2 这个方法在work进程的执行操作

  2. 向master发送queryServer消息，向master注册一个内部TCP服务器

  1. // lib/internal/cluster/child.js
  2. cluster._getServer = function(obj, options, cb) {
  3.  // ...
  4.  const message = util._extend({
  5.   act: 'queryServer',  // 关键点：构建一个queryServer的消息
  6.   index: indexes[indexesKey],
  7.   data: null
  8.  }, options);
  9.  message.address = address;
  10. // 发送queryServer消息给master进程，master 在收到这个消息后，会创建一个开始一个server，并且listen
  11.  send(message, (reply, handle) => {
  12.    rr(reply, indexesKey, cb);       // Round-robin.
  13.  });
  14.  obj.once('listening', () => {
  15.   cluster.worker.state = 'listening';
  16.   const address = obj.address();
  17.   message.act = 'listening';
  18.   message.port = address && address.port || options.port;
  19.   send(message);
  20.  });
  21. };
  22.  //...
  23.  // Round-robin. Master distributes handles across workers.
  24. function rr(message, indexesKey, cb) {
  25.   if (message.errno) return cb(message.errno, null);
  26.   var key = message.key;
  27.   // 这里hack 了listen方法
  28.   // 子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误
  29.   function listen(backlog) {
  30.     return 0;
  31.   }
  32.   // ...
  33.   const handle = { close, listen, ref: noop, unref: noop };
  34.   handles[key] = handle;
  35.   // 这个cb 函数是net.js 中的listenOnMasterHandle 方法
  36.   cb(0, handle);
  37. }
  38. // lib/net.js
  39. /*
  40. function listenOnMasterHandle(err, handle) {
  41.   err = checkBindError(err, port, handle);
  42.   server._handle = handle;
  43.   // _listen2 函数中,调用的handle.listen方法，也就是上面被hack的listen
  44.   server._listen2(address, port, addressType, backlog, fd);
  45.  }
  46. */

master进程收到queryServer消息后进行启动服务

  1. 如果地址没被监听过，通过RoundRobinHandle监听开启服务

  2. 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求

  1. // lib/internal/cluster/master.js
  2. function queryServer(worker, message) {
  3.   const args = [
  4.     message.address,
  5.     message.port,
  6.     message.addressType,
  7.     message.fd,
  8.     message.index
  9.   ];
  10.   const key = args.join(':');
  11.   var handle = handles[key];
  12.   // 如果地址没被监听过，通过RoundRobinHandle监听开启服务
  13.   if (handle === undefined) {
  14.     var constructor = RoundRobinHandle;
  15.     if (schedulingPolicy !== SCHED_RR ||
  16.       message.addressType === 'udp4' ||
  17.       message.addressType === 'udp6') {
  18.       constructor = SharedHandle;
  19.     }
  20.     handles[key] = handle = new constructor(key,
  21.       address,
  22.       message.port,
  23.       message.addressType,
  24.       message.fd,
  25.       message.flags);
  26.   }
  27.   // 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求
  28.   // Set custom server data
  29.   handle.add(worker, (errno, reply, handle) => {
  30.     reply = util._extend({
  31.       errno: errno,
  32.       key: key,
  33.       ack: message.seq,
  34.       data: handles[key].data
  35.     }, reply);
  36.     if (errno)
  37.       delete handles[key]; // Gives other workers a chance to retry.
  38.     send(worker, reply, handle);
  39.   });
  40. }

看到这一步，已经很明显，我们知道了多进行端口共享的实现原理

  1. 其实端口仅由master进程中的内部TCP服务器监听了一次

  2. 因为net.js 模块中会判断当前的进程是master还是Worker进程

  3. 如果是Worker进程调用cluster._getServer 去hack原生的listen 方法

  4. 所以在child调用的listen方法，是一个return 0 的空方法，所以不会报端口占用错误

那现在问题来了，既然Worker进程是如何获取到master进程监听服务接收到的connect呢？

  1. 监听master进程启动的TCP服务器的connection事件

  2. 通过轮询挑选出一个worker

  3. 向其发送newconn内部消息，消息体中包含了客户端句柄

  4. 有了句柄，谁都知道要怎么处理了哈哈

  1. // lib/internal/cluster/round_robin_handle.js
  2. function RoundRobinHandle(key, address, port, addressType, fd) {
  3.   this.server = net.createServer(assert.fail);
  4.   if (fd >= 0)
  5.     this.server.listen({ fd });
  6.   else if (port >= 0)
  7.     this.server.listen(port, address);
  8.   else
  9.     this.server.listen(address); // UNIX socket path.
  10.   this.server.once('listening', () => {
  11.     this.handle = this.server._handle;
  12.     // 监听onconnection方法
  13.     this.handle.onconnection = (err, handle) => this.distribute(err, handle);
  14.     this.server._handle = null;
  15.     this.server = null;
  16.   });
  17. }
  18. RoundRobinHandle.prototype.add = function (worker, send) {
  19.   // ...
  20. };
  21. RoundRobinHandle.prototype.remove = function (worker) {
  22.   // ...
  23. };
  24. RoundRobinHandle.prototype.distribute = function (err, handle) {
  25.   // 负载均衡地挑选出一个worker
  26.   this.handles.push(handle);
  27.   const worker = this.free.shift();
  28.   if (worker) this.handoff(worker);
  29. };
  30. RoundRobinHandle.prototype.handoff = function (worker) {
  31.   const handle = this.handles.shift();
  32.   const message = { act: 'newconn', key: this.key };
  33.   // 向work进程其发送newconn内部消息和客户端的句柄handle
  34.   sendHelper(worker.process, message, handle, (reply) => {
  35.   // ...
  36.     this.handoff(worker);
  37.   });
  38. };

下面让我们看看Worker进程接收到newconn消息后进行了哪些操作

  1. // lib/child.js
  2. function onmessage(message, handle) {
  3.   if (message.act === 'newconn')
  4.    onconnection(message, handle);
  5.   else if (message.act === 'disconnect')
  6.    _disconnect.call(worker, true);
  7.  }
  8. // Round-robin connection.
  9. // 接收连接，并且处理
  10. function onconnection(message, handle) {
  11.  const key = message.key;
  12.  const server = handles[key];
  13.  const accepted = server !== undefined;
  14.  send({ ack: message.seq, accepted });
  15.  if (accepted) server.onconnection(0, handle);
  16. }

总结

  1. net模块会对进程进行判断，是worker 还是master, 是worker的话进行hack net.Server实例的listen方法

  2. worker 调用的listen 方法是hack掉的，直接return 0,不过会向master注册一个connection接手的事件

  3. master 收到客户端connection事件后，会轮询向worker发送connection上来的客户端句柄

  4. worker收到master发送过来客户端的句柄，这时候就可以处理客户端请求了

相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！

推荐阅读：

Vue.js双向绑定项目实战分析

jquery如何判断元素内容为空

以上就是Node.Js中怎样实现端口重用功能的详细内容，更多请关注Gxl网其它相关文章！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！