Comment contrôler le nombre de simultanéités à l'aide d'async et enterproxy-js tutoriel-php.cn

Je pense que la concurrence est familière à tout le monde.Cet article vous présente principalement les informations pertinentes sur l'utilisation d'async et d'enterproxy pour contrôler le nombre de concurrence.L'article le présente en détail à travers un exemple de code, ce qui est d'une certaine importance pour l'étude de chacun. ou travailler. La valeur d'apprentissage de référence, les amis qui en ont besoin, veuillez étudier ensemble ci-dessous.

Parlons de concurrence et de parallélisme

La concurrence, dans le système d'exploitation, signifie que plusieurs programmes sont démarrés dans un laps de temps entre l'exécution et à la fin, ces programmes s'exécutent tous sur le même processeur, mais un seul programme s'exécute sur le processeur à tout moment.

La concurrence est quelque chose que nous mentionnons souvent. Qu'il s'agisse d'un serveur Web ou d'une application, la concurrence est partout dans le système d'exploitation, elle fait référence à plusieurs programmes dans un laps de temps entre le démarrage et l'exécution, et ces programmes. tous fonctionnent sur le même processeur et un seul programme s'exécute sur le processeur à tout moment. De nombreux sites Web ont des limites sur le nombre de connexions simultanées, donc lorsque les requêtes sont envoyées trop rapidement, la valeur de retour sera vide ou une erreur sera signalée. De plus, certains sites Web peuvent bloquer votre IP car vous envoyez trop de connexions simultanées et pensez que vous faites des requêtes malveillantes.

Comparé à la concurrence, le parallélisme peut être très inconnu. Le parallélisme fait référence à un groupe de programmes s'exécutant à une vitesse indépendante et asynchrone, qui n'est pas égale au chevauchement dans le temps (se produisant au même moment). Les cœurs peuvent être implémentés en augmentant le nombre de cœurs de processeur. Les programmes (tâches) sont exécutés simultanément. C'est vrai, le parallélisme permet d'effectuer plusieurs tâches simultanément

Utiliser enterproxy pour contrôler le nombre de simultanéités

enterproxy est un outil qui Pu Lingda a le plus contribué à , provoquant un changement dans la pensée de la programmation basée sur les événements, utilisant le mécanisme d'événements pour découpler la logique métier complexe, résolvant les critiques concernant le couplage des fonctions de rappel, transformant l'attente série en attente parallèle et améliorant l'efficacité de l'exécution. dans des scénarios de collaboration multi-asynchrones

Comment utiliser enterproxy pour contrôler le nombre de simultanéités ? Habituellement, si nous n'utilisons pas enterproxy et les compteurs faits maison, nous récupérons trois sources :

Cette imbrication profonde, de manière sérielle

 var render = function (template, data) {
 _.template(template, data);
 };
$.get("template", function (template) {
 // something
 $.get("data", function (data) {
 // something
 $.get("l10n", function (l10n) {
 // something
 render(template, data, l10n);
 });
 });
});

Copier après la connexion

Supprimer cette imbrication profonde dans le passé De manière conventionnelle, nous maintenons un compteur par nous-mêmes

(function(){
 var count = 0;
 var result = {};
 
 $.get(&#39;template&#39;,function(data){
 result.data1 = data;
 count++;
 handle();
 })
 $.get(&#39;data&#39;,function(data){
 result.data2 = data;
 count++;
 handle();
 })
 $.get(&#39;l10n&#39;,function(data){
 result.data3 = data;
 count++;
 handle();
 })

 function handle(){
 if(count === 3){
  var html = fuck(result.data1,result.data2,result.data3);
  render(html);
 }
 }
})();

Copier après la connexion

Ici, enterproxy peut jouer le rôle de ce compteur. Il vous aide à gérer si ces opérations asynchrones sont terminées, il appellera automatiquement la fonction de traitement que vous fournissez et. transmettre les données capturées en tant que paramètres

var ep = new enterproxy();
ep.all(&#39;data_event1&#39;,&#39;data_event2&#39;,&#39;data_event3&#39;,function(data1,data2,data3){
 var html = fuck(data1,data2,data3);
 render(html);
})

$.get(&#39;http:example1&#39;,function(data){
 ep.emit(&#39;data_event1&#39;,data);
})

$.get(&#39;http:example2&#39;,function(data){
 ep.emit(&#39;data_event2&#39;,data);
})

$.get(&#39;http:example3&#39;,function(data){
 ep.emit(&#39;data_event3&#39;,data);
})

Copier après la connexion

enterproxy fournit également les API requises pour de nombreux autres scénarios. Vous pouvez apprendre cette API enterproxy par vous-même

Utiliser async pour contrôler le. nombre de concurrence

Si nous avons 40 requêtes à envoyer, de nombreux sites Web peuvent échouer car vous envoyez trop de connexions simultanées. Vous faites une requête malveillante et votre IP sera bloquée.
Nous devons donc toujours contrôler le nombre de concurrence, puis explorer lentement ces 40 liens.

Utilisez mapLimit en asynchrone pour contrôler le nombre de simultanéités à 5 et ne capturer que 5 liens à la fois.

 async.mapLimit(arr, 5, function (url, callback) {
 // something
 }, function (error, result) {
 console.log("result: ")
 console.log(result);
 })

Copier après la connexion

Nous devons d'abord savoir ce qu'est la simultanéité, pourquoi nous devons limiter le nombre de simultanéités et quelles solutions sont disponibles. Ensuite, vous pouvez accéder à la documentation pour voir comment utiliser l'API. La documentation asynchrone est un excellent moyen d'apprendre ces syntaxes.

Simulez un ensemble de données. Les données renvoyées ici sont fausses et le délai de retour est aléatoire.

var concurreyCount = 0;
var fetchUrl = function(url,callback){
 // delay 的值在 2000 以内，是个随机的整数 模拟延时
 var delay = parseInt((Math.random()* 10000000) % 2000,10);
 concurreyCount++;
 console.log(&#39;现在并发数是 &#39; , concurreyCount , &#39; 正在抓取的是&#39; , url , &#39; 耗时&#39; + delay + &#39;毫秒&#39;);
 setTimeout(function(){
 concurreyCount--;
 callback(null,url + &#39; html content&#39;);
 },delay);
}

var urls = [];
for(var i = 0;i<30;i++){
 urls.push(&#39;http://datasource_&#39; + i)
}

Copier après la connexion

Ensuite, nous utilisons async.mapLimit pour explorer simultanément et obtenir les résultats.

async.mapLimit(urls,5,function(url,callback){
 fetchUrl(url,callbcak);
},function(err,result){
 console.log(&#39;result: &#39;);
 console.log(result);
})

Copier après la connexion

La simulation est extraite de Alsotang

Après avoir exécuté la sortie, les résultats suivants sont obtenus

Nous avons constaté que le le nombre de concurrence passe de 1, mais lorsqu'il atteint 5, il cesse d'augmenter. Lorsqu'il y a des tâches, continuez à explorer et le nombre de connexions simultanées est toujours contrôlé à 5.

Complétez le système d'exploration simple du nœud

Parce que la concurrence contrôlée par eventproxy est utilisée dans l'exemple du didacticiel "le nœud inclut l'enseignement mais pas la réunion " Par Alsotang senior Quantity, complétons un simple robot d'exploration de nœuds qui utilise l'asynchrone pour contrôler le nombre de concurrences.

La cible du crawl est la page d'accueil de ce site Web (protection manuelle du visage)

Dans la première étape, nous devons utiliser les modules suivants :

url : utilisé pour l'analyse des url, ici url.resolve() est utilisé pour générer un nom de domaine légal
async : un module pratique qui fournit des fonctions puissantes et un travail JavaScript asynchrone
cheerio : une implémentation de base jQuery rapide et flexible spécialement personnalisée pour le serveur
superagent : une demande client très pratique dans le module Agent nodejs

Installez le module dépendant via npm

La deuxième étape consiste à introduire le module dépendant via require et à déterminer l'URL de l'objet d'exploration :

var url = require("url");
var async = require("async");
var cheerio = require("cheerio");
var superagent = require("superagent");
var baseUrl = &#39;http://www.chenqaq.com&#39;;

Copier après la connexion

Étape 3 : utilisez superagent pour demander l'URL cible et utilisez cheerio pour traiter baseUrl afin d'obtenir l'URL du contenu cible, et enregistrez-la dans le tableau arr

superagent.get(baseUrl)
 .end(function (err, res) {
 if (err) {
  return console.error(err);
 }
 var arr = [];
 var $ = cheerio.load(res.text);
 // 下面和jQuery操作是一样一样的..
 $(".post-list .post-title-link").each(function (idx, element) {
  $element = $(element);
  var _url = url.resolve(baseUrl, $element.attr("href"));
  arr.push(_url);
 });
 // 验证得到的所有文章链接集合
 output(arr);
 // 第四步：接下来遍历arr，解析每一个页面需要的信息
})

Copier après la connexion

Nous avons besoin une fonction pour vérifier la capture L'objet url obtenu est très simple Nous avons seulement besoin d'une fonction pour parcourir arr et l'imprimer :

function output(arr){
 for(var i = 0;i<arr.length;i++){
  console.log(arr[i]);
 }
}

Copier après la connexion

第四步：我们需要遍历得到的URL对象，解析每一个页面需要的信息。

这里就需要用到async控制并发数量，如果你上一步获取了一个庞大的arr数组，有多个url需要请求，如果同时发出多个请求，一些网站就可能会把你的行为当做恶意请求而封掉你的ip

async.mapLimit(arr,3,function(url,callback){
 superagent.get(url)
  .end(function(err,mes){
   if(err){
    console.error(err);
    console.log(&#39;message info &#39; + JSON.stringify(mes));
   }
   console.log(&#39;「fetch」&#39; + url + &#39; successful！&#39;);
   var $ = cheerio.load(mes.text);
   var jsonData = {
    title:$(&#39;.post-card-title&#39;).text().trim(),
    href: url,
   };
   callback(null,jsonData);
  },function(error,results){
   console.log(&#39;results &#39;);
   console.log(results);
  })
 })

Copier après la connexion

得到上一步保存url地址的数组arr，限制最大并发数量为3，然后用一个回调函数处理「该回调函数比较特殊，在iteratee方法中一定要调用该回调函数，有三种方式」