Maison > Article > interface Web > 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"
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
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
, 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
épuisement, des erreurs réseau causées par une bande passante insuffisante, des erreurs causées par des restrictions de port, etc. peuvent survenir. 文件描述符
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
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
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
(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)
<.>
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
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!