Comment node.js « multi-threading » gère-t-il les tâches à haute concurrence ?

L'article suivant vous présentera comment utiliser nodejs "multi-threading" pour gérer des tâches à haute concurrence. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Recommandations associées : "Tutoriel vidéo nodejs"

Loi de Moore

Moore La loi a été proposée par le cofondateur d'Intel, Gordon Moore, en 1965, c'est-à-dire que le nombre de composants pouvant être hébergés sur un circuit intégré doublera tous les 18 à 24 mois et que les performances augmenteront également d'une fois. Autrement dit, les performances du processeur (CPU) doublent tous les deux ans environ.

Plus de 50 ans se sont écoulés depuis que la loi de Moore a été proposée. Aujourd'hui, à mesure que les composants des puces se rapprochent de l'échelle d'un seul atome, il devient de plus en plus difficile de respecter la loi de Moore.

En 2019, Jensen Huang, PDG de NVIDIA, a déclaré lors du salon ECS : "La loi de Moore augmentait de 10 fois tous les 5 ans et de 100 fois tous les 10 ans. Mais aujourd'hui, la loi de Moore ne peut croître que de quelques points de pourcentage. chaque année. , peut-être seulement 2 fois tous les 10 ans. Par conséquent, la loi de Moore est terminée "

Les performances d'un seul processeur (CPU) se rapprochent de plus en plus du goulot d'étranglement. Si vous voulez percer. ce goulot d'étranglement, vous devez en tirer pleinement parti, permettant à un ou plusieurs 多线程技术 d'exécuter plusieurs threads en même temps pour effectuer les tâches informatiques plus rapidement. CPU

Multi-threading de Node

Nous savons tous que

est un langage monothread Javascript profite des fonctionnalités de Nodejs et utilise. le modèle basé sur les événements pour réaliser des E/S asynchrones, et derrière les E/S asynchrones se trouve la planification multithread. Javascript

Pour l'implémentation des E/S asynchrones, vous pouvez vous référer au "Node.js en termes simples" de Pu Ling Node

Dans le langage

, vous pouvez appeler explicitement un programme en créant Go Nouveaux threads, et contrôlez le nombre maximum de concurrences via des variables d'environnement Goroutine. GOMAXPROCS

Dans

, il n'y a pas de Node qui peut explicitement créer un nouveau thread API implémente certaines API d'E/S asynchrones, telles que Node, fs.readFile. La couche inférieure de ces E/S asynchrones consiste à appeler de nouveaux threads pour effectuer des tâches asynchrones, puis à utiliser le modèle basé sur les événements pour obtenir les résultats d'exécution. http.request

Le développement côté serveur et le développement d'outils peuvent nécessiter l'utilisation d'un développement multithread. Par exemple, utilisez le multi-threading pour gérer des tâches de robot d'exploration complexes, utilisez le multi-threading pour gérer les requêtes simultanées, utilisez le multi-threading pour le traitement des fichiers, etc...

Lorsque nous utilisons le multi-threading, nous devons contrôler le nombre maximum de simultanéités. Étant donné que le nombre maximum de simultanéités n'est pas contrôlé, des erreurs causées par

épuisement, des erreurs réseau causées par une bande passante insuffisante, des erreurs causées par des restrictions de port, etc. peuvent survenir. 文件描述符

Il n'y a pas de

ou de variable d'environnement utilisée pour contrôler le nombre maximum de simultanéités dans Node, donc ensuite, nous utiliserons quelques lignes de code simples pour l'implémenter. API

Implémentation du code

Supposons d'abord le scénario de demande suivant. J'ai un robot qui doit explorer 100 articles Nugget chaque jour. L'exploration est trop lente. . L'exploration de 100 articles à la fois entraînera l'échec direct de nombreuses requêtes en raison d'un trop grand nombre de connexions réseau.

Ensuite, nous pouvons le mettre en œuvre, en demandant 10 articles à chaque fois et en le complétant en 10 fois. Cela peut non seulement augmenter l'efficacité de 10 fois, mais également garantir un fonctionnement stable.

Jetons un coup d'œil à une seule tâche de requête. Le code est implémenté comme suit :

const axios = require("axios");

async function singleRequest(article_id) {
  // 这里我们直接使用 axios 库进行请求
  const reply = await axios.post(
    "https://api.juejin.cn/content_api/v1/article/detail",
    {
      article_id,
    }
  );

  return reply.data;
}

Pour faciliter la démonstration, nous demandons ici la même adresse 100 fois. . Le code L'implémentation est la suivante :

// 请求任务列表
const requestFnList = new Array(100)
  .fill("6909002738705629198")
  .map((id) => () => singleRequest(id));

Ensuite, implémentons la méthode de requête concurrente. Cette méthode prend en charge l'exécution de plusieurs tâches asynchrones en même temps et peut limiter le nombre maximum de simultanéités. Une fois qu'une tâche du pool de tâches est exécutée, une nouvelle tâche asynchrone sera poussée pour poursuivre l'exécution afin de garantir une utilisation élevée du pool de tâches. Le code est implémenté comme suit :

const chalk = require("chalk");
const { log } = require("console");

/**
 * 执行多个异步任务
 * @param {*} fnList 任务列表
 * @param {*} max 最大并发数限制
 * @param {*} taskName 任务名称
 */
async function concurrentRun(fnList = [], max = 5, taskName = "未命名") {
  if (!fnList.length) return;

  log(chalk.blue(`开始执行多个异步任务，最大并发数： ${max}`));
  const replyList = []; // 收集任务执行结果
  const count = fnList.length; // 总任务数量
  const startTime = new Date().getTime(); // 记录任务执行开始时间

  let current = 0;
  // 任务执行程序
  const schedule = async (index) => {
    return new Promise(async (resolve) => {
      const fn = fnList[index];
      if (!fn) return resolve();

      // 执行当前异步任务
      const reply = await fn();
      replyList[index] = reply;
      log(`${taskName} 事务进度 ${((++current / count) * 100).toFixed(2)}% `);

      // 执行完当前任务后，继续执行任务池的剩余任务
      await schedule(index + max);
      resolve();
    });
  };

  // 任务池执行程序
  const scheduleList = new Array(max)
    .fill(0)
    .map((_, index) => schedule(index));
  // 使用 Promise.all 批量执行
  const r = await Promise.all(scheduleList);

  const cost = (new Date().getTime() - startTime) / 1000;
  log(chalk.green(`执行完成，最大并发数： ${max}，耗时：${cost}s`));
  return replyList;
}

Comme le montre le code ci-dessus, la clé pour utiliser

pour les requêtes simultanées est Node, et Promise.all peut exécuter plusieurs tâches asynchrones en même temps. temps. Promise.all

Dans le code ci-dessus, un tableau d'une longueur de

le nombre maximum de tâches simultanées est créé et le nombre correspondant de tâches asynchrones est placé dans le tableau. Utilisez ensuite max pour exécuter ces tâches asynchrones en même temps. Lorsqu'une seule tâche asynchrone est terminée, une nouvelle tâche asynchrone sera retirée du pool de tâches pour poursuivre l'exécution, maximisant ainsi l'efficacité. Promise.all

Ensuite, nous utilisons le code suivant pour effectuer le test d'exécution (le code est implémenté comme suit)

(async () => {
  const requestFnList = new Array(100)
    .fill("6909002738705629198")
    .map((id) => () => singleRequest(id));

  const reply = await concurrentRun(requestFnList, 10, "请求掘金文章");
})();

Le résultat final de l'exécution est le suivant :

À ce stade, notre demande concurrente est complétée ! Testons ensuite la vitesse de différentes simultanéités ~ La première est 1 simultanéité, c'est-à-dire aucune simultanéité (comme indiqué ci-dessous)

Cela prend 11,462 secondes ! Lorsque la simultanéité n'est pas utilisée, la tâche prend très longtemps. Voyons ensuite combien de temps cela prend dans d'autres conditions de simultanéité (comme indiqué ci-dessous)

<.>

Comme le montre la figure ci-dessus, à mesure que notre nombre de concurrence augmente, la vitesse d'exécution des tâches devient de plus en plus rapide ! C’est l’avantage de la forte simultanéité, qui peut améliorer l’efficacité plusieurs fois, voire des dizaines de fois dans certains cas !

Si nous examinons de plus près la consommation de temps ci-dessus, nous constaterons qu'à mesure que le nombre de concurrence augmente, la consommation de temps aura toujours un seuil et ne pourra pas augmenter complètement par multiples. En effet,

n'ouvre pas réellement un thread pour chaque tâche à traiter, mais ouvre uniquement un nouveau thread pour les tâches Node asynchrones. Par conséquent, I/O est plus adapté au traitement de Node tâches intensives, mais ne convient pas aux tâches I/O (de calcul) intensives. CPU

À ce stade, nous avons fini d'introduire l'utilisation du "multi-threading" Node pour gérer les tâches à haute concurrence. Si vous souhaitez que le programme soit plus parfait, vous devez également prendre en compte le mécanisme de délai d'attente des tâches et de tolérance aux pannes. Si vous êtes intéressé, vous pouvez le mettre en œuvre vous-même.

Pour plus de connaissances sur la programmation, veuillez visiter :

Introduction à la programmation ! !

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!