So steuern Sie die Anzahl der Parallelitäten mithilfe von Async und Enterproxy

Ich glaube, dass Parallelität jedem bekannt ist. In diesem Artikel werden Ihnen hauptsächlich die relevanten Informationen zur Verwendung von Async und Enterproxy zur Steuerung der Parallelität vorgestellt oder Arbeit, Freunde, die es brauchen, lernen bitte unten zusammen.

Sprechen wir über Parallelität und Parallelität

Parallelität bedeutet im Betriebssystem, dass mehrere Programme in einem bestimmten Zeitraum zwischen der Ausführung gestartet werden und Abschluss laufen diese Programme alle auf demselben Prozessor, aber zu jedem Zeitpunkt läuft nur ein Programm auf dem Prozessor.

Parallelität ist etwas, das wir oft erwähnen. Unabhängig davon, ob es sich um einen Webserver oder eine App handelt, bezieht sich die Parallelität auf mehrere Programme in einem Zeitraum zwischen dem Start und der Ausführung Alle laufen auf demselben Prozessor, und zu jedem Zeitpunkt läuft nur ein Programm auf dem Prozessor. Bei vielen Websites ist die Anzahl gleichzeitiger Verbindungen begrenzt. Wenn Anfragen also zu schnell gesendet werden, ist der Rückgabewert leer oder es wird ein Fehler gemeldet. Darüber hinaus blockieren einige Websites möglicherweise Ihre IP-Adresse, weil Sie zu viele gleichzeitige Verbindungen senden und glauben, dass Sie böswillige Anfragen stellen.

Parallelität ist im Vergleich zur Parallelität möglicherweise etwas ungewohnt. Parallelität bezieht sich auf eine Gruppe von Programmen, die mit einer unabhängigen und asynchronen Geschwindigkeit ausgeführt werden, was nicht gleichbedeutend mit einer zeitlichen Überlappung ist (die gleichzeitig mit mehreren CPUs auftritt). Durch die Erhöhung der Anzahl der CPU-Kerne können Programme (Aufgaben) gleichzeitig ausgeführt werden. Richtig, Multitasking kann parallel ausgeführt werden

Verwenden Sie Enterproxy, um die Anzahl der Parallelitäten zu steuern

Enterproxy ist ein Tool, das Pu Lingda entwickelt hat Hauptbeitrag zu , führt zu einer Änderung des Denkens der ereignisbasierten Programmierung, nutzt den Ereignismechanismus zur Entkopplung komplexer Geschäftslogik, löst die Kritik an der Kopplung von Rückruffunktionen, wandelt serielles Warten in paralleles Warten um und verbessert die Ausführungseffizienz in Multi -asynchrone Kollaborationsszenarien

Wie verwenden wir Enterproxy, um die Anzahl der Parallelitäten zu steuern? Wenn wir keinen Enterproxy und keine hausgemachten Zähler verwenden, greifen wir normalerweise zu drei Quellen:

Diese tief verschachtelte, serielle Methode

 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);
 });
 });
});

Entfernen Sie diese tief in der Vergangenheit verschachtelte Methode, unsere herkömmliche Schreibweise besteht darin, einen Zähler selbst zu pflegen

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

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

Hier kann enterproxy die Rolle dieses Zählers übernehmen. Es hilft Ihnen bei der Verwaltung, ob diese asynchronen Vorgänge abgeschlossen sind, und ruft Sie automatisch auf, um die Verarbeitungsfunktion bereitzustellen Übergeben Sie die erfassten Daten als Parameter

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

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

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

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

enterproxy stellt auch APIs bereit, die für viele andere Szenarien erforderlich sind. Sie können diese API selbst erlernen enterproxy

Verwenden Sie asynchron, um die Anzahl der zu steuern Parallelität

Wenn wir 40 Anfragen stellen müssen, gehen viele Websites davon aus, dass Sie böswillige Anfragen stellen, weil Sie zu viele gleichzeitige Verbindungen senden. Blockieren Sie Ihre IP.
Wir müssen also immer die Anzahl der Parallelitäten kontrollieren und dann diese 40 Links langsam crawlen.

Verwenden Sie mapLimit asynchron, um die einmalige Parallelitätszahl auf 5 zu steuern und jeweils nur 5 Links zu erfassen.

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

Wir sollten zunächst wissen, was Parallelität ist, warum wir die Anzahl der Parallelitäten begrenzen müssen und welche Lösungen verfügbar sind. Anschließend können Sie in der Dokumentation nachlesen, wie Sie die API verwenden. Die asynchrone Dokumentation ist eine großartige Möglichkeit, diese Syntaxen zu erlernen.

Simulieren Sie einen Datensatz. Die hier zurückgegebenen Daten sind falsch und die Rückgabeverzögerung ist zufällig.

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

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

Dann verwenden wir async.mapLimit, um gleichzeitig zu crawlen und die Ergebnisse zu erhalten.

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

Die Simulation ist ein Auszug aus alsotang

Die folgenden Ergebnisse werden nach dem Ausführen der Ausgabe erhalten

Wir haben festgestellt, dass die Anzahl der Parallelität beginnt bei 1, wächst aber bis 5 Uhr und nimmt nicht mehr zu. Wenn Aufgaben vorhanden sind, wird der Crawl fortgesetzt, und die Anzahl gleichzeitiger Verbindungen wird immer auf 5 gesteuert.

Vervollständigen Sie das einfache Node-Crawler-System

Da die von Eventproxy gesteuerte Parallelität im Tutorial-Beispiel „Knoten umfasst Unterricht, aber keine Besprechung“ verwendet wird „von alsotang senior Quantität, lassen Sie uns einen einfachen Node-Crawler fertigstellen, der Async verwendet, um die Anzahl der Parallelitäten zu steuern.

Ziel des Crawlings ist die Homepage dieser Website (manueller Gesichtsschutz)

Im ersten Schritt müssen wir folgende Module verwenden:

• URL: wird für die URL-Analyse verwendet, hier wird url.resolve() verwendet, um einen legalen Domänennamen zu generieren

• async: ein praktisches Modul, das leistungsstarke Funktionen und asynchrone JavaScript-Arbeit bereitstellt

• Cheerio: eine schnelle, flexible JQuery-Kernimplementierung, die speziell für den Server angepasst wurde

• Superagent: eine sehr praktische Client-Anfrage im NodeJS-Agentenmodul

Installieren Sie das abhängige Modul über npm

Der zweite Schritt besteht darin, das abhängige Modul über require einzuführen und die URL des Crawling-Objekts zu bestimmen:

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

Schritt 3: Verwenden Sie Superagent, um die Ziel-URL anzufordern, und verwenden Sie cheerio, um baseUrl zu verarbeiten, um die Zielinhalts-URL zu erhalten, und speichern Sie sie im Array 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，解析每一个页面需要的信息
})

Wir benötigen eine Funktion zur Überprüfung Das gecrawlte URL-Objekt ist sehr einfach. Wir benötigen nur eine Funktion, um arr zu durchlaufen und auszudrucken:

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

第四步：我们需要遍历得到的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('message info ' + JSON.stringify(mes));
   }
   console.log('「fetch」' + url + ' successful！');
   var $ = cheerio.load(mes.text);
   var jsonData = {
    title:$('.post-card-title').text().trim(),
    href: url,
   };
   callback(null,jsonData);
  },function(error,results){
   console.log('results ');
   console.log(results);
  })
 })

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

• callback(null) 调用成功

• callback(null，data) 调用成功，并且返回数据data追加到results

• callback(data) 调用失败，不会再继续循环，直接到最后的callback

好了，到这里我们的node简易的小爬虫就完成了，来看看效果吧

嗨呀，首页数据好少，但是成功了呢。

参考资料

Node.js 包教不包会 - alsotang

enterproxy

async

async Documentation

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

在js中如何实现登录需要滑动验证

在js中如何实现判断文件类型大小

在vue中如何使用cdn优化

Das obige ist der detaillierte Inhalt vonSo steuern Sie die Anzahl der Parallelitäten mithilfe von Async und Enterproxy. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!