Le nœud peut-il activer le multithread ?

Node peut activer le multithreading ; vous pouvez utiliser le module "child_process" fourni avec le nœud pour activer le multithreading. La syntaxe est "child_process.fork(modulePath[, args][, options])" ; pour créer exec et execFile Il existe quatre types de processus enfants : , spawn et fork.

L'environnement d'exploitation de ce tutoriel : système windows10, nodejs version 12.19.0, ordinateur Dell G3.

Le nœud peut-il activer le multi-thread ?

Le nœud peut-il activer le multi-thread ?

Nous savons tous que Node.js fonctionne en mode monothread, mais il utilise la gestion des événements pour gérer la concurrence. piloté par les événements, non- Le modèle d'E/S bloquant utilise pleinement les E/S asynchrones fournies par le système d'exploitation pour effectuer des tâches multitâches et convient aux scénarios d'application à forte intensité d'E/S. le programme n'a pas besoin de bloquer et d'attendre que le résultat soit renvoyé

L'émergence du multi-thread NodeJS n'est pas dans le but d'améliorer la concurrence, mais d'améliorer pleinement l'utilisation du processeur

Plusieurs façons d'ouvrir le multi-threads

Utilisez le module child_process fourni avec Node

child_process.fork(modulePath[, args][, options])

Dérivez un nouveau processus Node.js et utilisez le canal de communication IPC établi (il autorise l'envoi de messages entre les processus parent et enfant) Appelez le module spécifié

cluster Le module cluster peut facilement créez des processus enfants qui partagent le port du serveur. Le processus de travail est généré à l'aide de la méthode child_process.fork()

Utilisez multi-processus

express

Créez trois nouveaux fichiers server.js (service express) cluster.js. (fichier de service multithread) extensionServer.js (sous-service express)
Les opérations suivantes garantissent qu'express est installé

npm intsall express --seve-dev

extensionServer.js Utilisez express pour créer des sous-services

const express = require("express"), //Express框架
app = express();

// api 先关接口
app.all('/userinfo', (req, res) => {
  res.json({ name: '自夏', msg: '我在自夏 selfsummer' })
})

app.listen(4000, () => {
 console.log(`子服务启动成功`);
})

serve.js Créez d'abord le service multithread Express

const  { fork } = require("child_process"),
express = require("express"), //Express框架
app = express();

const { pid, ppid } = require('process')

// api 先关接口
app.all('/123', (req, res, next) => {
   console.log(`本次进程id为: ${pid}`);
  res.end(`本次进程id为: ${pid}`)
})

app.all('/456', (req, res, next) => {
  console.log(`本次进程id为: ${pid}`);
  res.end(`本次进程id为: ${pid}`)
})


app.listen(3888, () => {
 console.log(`服务器端启动成功 父进程 ${ppid} 当前服务进程id为 ${pid}`);
 // 开启多进程
 fork('extensionServer.js')
})

module.exports = {
  app,
  express,
};

Démarrez le service À ce moment, le service principal et le libre-service sont démarrés

Accédez au service principal Express et aux adresses des sous-services. réussir

cluster.js Changez le service Express en cluster

Utilisez le module de cluster de cluster pour activer le multi-threading

const os = require('os');
const cluster = require('cluster');
const { log } = console;
const express = require("express"); //Express框架

const app = express();
const processId = process.pid;

// 判断当前是否有主进程
if (cluster.isMaster)
{
	// 获取当前本机cpu核数，开启多线程
  const cpus = os.cpus().length;
  for (let i = 0; i < cpus; i++){
    cluster.fork()
  }
	//进程已断开连接	
	  cluster.on(&#39;disconnect&#39;, (worker) => {
	    console.log(`进程号 #${worker.id} 已断开`);
	  });
	// 意外退出进程
	cluster.on(&#39;exit&#39;, (worker, code, signal) => {
	      cluster.fork();
  	});


} else
{
	// 引用Express主服务 开启主进程  
  require(&#39;./server&#39;)
}

Démarrez le cluster de nœuds de service de cluster

Bien sûr, vous pouvez également continuer à ouvrir des processus enfants dans le cluster

Visitez deux fois (un accès au navigateur, un accès au facteur) l'interface arrière

Pourquoi y en a-t-il plusieurs Le serveur a démarré avec succès est xxx

Il devrait s'agir d'un module de cluster. -process est généré sous le processus principal actuel, et chaque sous-processus est Le processus est un nouveau processus dérivé de tous les
du processus principal. Les processus sont indépendants les uns des autres. Chaque processus a sa propre instance V8 et sa propre mémoire. Les ressources du système sont limitées. Il n'est pas recommandé de générer trop de processus enfants. Cela dépend des paramètres du système *
Numéro de cœur du processeur*

Nous avons déjà jugé s'il existe un processus principal

S'il existe un processus principal, utilisez le module cluster pour ouvrir le processus enfant

Sinon, démarrez le processus

Changez le service Express par défaut http Le service

n'a besoin que de modifier le contenu du fichier server.js

const http = require('http')const { pid, ppid } = require('process')const server = http.createServer((req, res) => {
  res.end(router(req.url))})const router = (url) => {
  switch (url)
  {
    case '/132':
      return `进程${pid} 很高兴为你服务`;
    case '/456':
      return `进程${pid} 很高兴为你服务`;
    default: return `没有此接口`
  }}server.listen(3889, () => {
  console.log(`Server Started in process ${pid}`);})

Démarrez toujours cluster.js ( fichier de service multithread)

Apprentissage recommandé : "tutoriel vidéo Nodejs"

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!