Node.Jsでポート再利用機能を実装する方法

今回はNode.Jsでポート再利用機能を実装する方法と、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(&#39;exit&#39;, (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`);
}

実行結果:

$ノードserver.js
マスター3596が実行中
ワーカー4324が開始されました
ワーカー4520が開始されました
ワーカー6056が開始されました
ワーカー5644が開始されました

http.js モジュールを理解します:

必要なのは http サービスを作成することだけであり、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);
}
 ...

その答えは次のとおりです。このメソッドは、ワークプロセスで操作を実行し、マスターに queryServer メッセージを送信し、マスターに内部 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);
 }
*/

マスタープロセスはqueryServerメッセージを受信した後にサービスを開始します
アドレスが監視されていない場合は、RoundRobinHandle監視を通じてサービスを開始します
アドレスが監視されている場合は、ハンドルを直接バインドします。監視対象のサービスを呼び出し、リクエストを消費しに行きます

// 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);
  });
}

このステップを参照してください。マルチポート共有の実装原理を知っていることはすでに明らかです
実際、ポートは内部 TCP によって 1 回だけリッスンされますマスタープロセスのサーバー
現在のプロセスがマスターであるかマスタープロセスであるかはnet.jsモジュールによって決定されるため

ワーカープロセスがcluster._getServerを呼び出す場合は、ネイティブのlistenメソッドをハックします

1. 。

そのため、子で呼び出される listen メソッドは 0 を返す空のメソッドであるため、ポート占有エラーは報告されません
ここで疑問が生じます。ワーカープロセスはマスタープロセスによって受信された接続をどのように取得するのでしょうか聞き取りサービス？
マスタープロセスによって開始されたTCPサーバーの接続
4. イベントをリッスン

ポーリングを通じてワーカーを選択

1. し、メッセージ本文にはクライアントハンドルが含まれています。

ハンドルを使えば、誰でも何をすべきかわかります (笑)

2. // 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);
     });
   };

newconn メッセージを受信した後に Worker プロセスが実行した操作を見てみましょう

3. // 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);
   }

概要

net モジュールがプロセスに対して行う処理ワーカーかマスターかを判断します。ワーカーの場合は、ネットサーバーインスタンスの listen メソッドをハックします

ワーカーが呼び出す listen メソッドはハックされ、直接 0 を返しますが、接続イベントはマスターに登録されます

クライアント接続イベントを受信した後、マスターは接続からクライアントハンドルをポーリングしてワーカーに送信します
ワーカーはマスターによって送信されたクライアントハンドルを受信し、処理できるようになりますクライアントのリクエスト
この記事の事例を読んだ後は、この方法を習得したと思います。さらに興味深い情報については、PHP 中国語 Web サイトの他の関連記事に注目してください。

3. 推奨読書:

4. Vue.js 双方向バインディング プロジェクトの実践的な分析

jquery が要素のコンテンツが空であることをどのように判断するか

以上がNode.Jsでポート再利用機能を実装する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。