Maison > Article > interface Web > Comment implémenter la fonction de réutilisation des ports dans Node.Js
Cette fois, je vais vous montrer comment implémenter la fonction de réutilisation de port dans Node.Js, et quelles sont les précautions pour implémenter la fonction de réutilisation de port dans Node.Js. Voici un cas pratique. Jetons un coup d’œil.
Origine, voir port partagé multi-processus depuis l'instance officielle
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`); }
Résultat de l'exécution :
$ node server.js
Master 3596 est en cours d'exécution
Worker 4324 démarré
Worker 4520 démarré
Worker 6056 démarré
Worker 5644 démarré
Comprendre le module http.js :
Nous avons tous pour créer Un service http doit référencer le module http. Le module http finira par appeler net.js pour implémenter le service réseau
// 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); } ...
La réponse pourra être trouvée prochainement via le cluster. Fonction _getServer
Serveur proxy._listen2 Cette méthode effectue des opérations dans le processus de travail
Envoie un message queryServer au maître et enregistre un TCP interne serveur avec le maître
// 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); } */
Le processus maître démarre le service après réception du message queryServer
Si l'adresse n'a pas été surveillée, démarrez le service via la surveillance RoundRobinHandle
Si l'adresse a été surveillée, liez directement le handle au service qui a été surveillé et allez consommer la demande
// 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); }); }
Vu cette étape, c'est déjà très simple. Evidemment, on connaît le principe de mise en œuvre du partage multi-port
En fait, le port est seulement écouté. une fois par le serveur TCP interne dans le processus maître
Parce que le module net.js déterminera si le processus actuel est un processus maître ou un processus Worker
Si le processus Worker appelle cluster._getServer, piratez la méthode d'écoute native
Donc la méthode d'écoute appelée dans l'enfant est une méthode vide qui renvoie 0, donc l'erreur d'occupation du port ne sera pas signalé
Maintenant, la question est, puisque comment se déroule le processus Worker Comment obtenir la connexion reçue par le service d'écoute du processus maître ?
Écoutez l'événement de connexion du serveur TCP démarré par le processus maître
Sélectionnez un travailleur via un sondage
Envoyez-lui un message interne à newconn, le corps du message contient le handle du client
Avec le handle, tout le monde sait quoi faire haha
// 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); }); };
Voyons quelles opérations le processus Worker a effectuées après avoir reçu le message 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); }
Résumé
Le module net jugera le processus, qu'il s'agisse d'un travailleur ou d'un maître. S'il s'agit d'un travailleur, piratez la méthode d'écoute de l'instance net.Server
Analyse pratique du projet de liaison bidirectionnelle Vue.js
Comment jquery détermine que le contenu de l'élément est vide
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!