Javascript - 如何控制并行访问网络的承诺数量 [英] Javascript - how to control how many promises access network in parallel
问题描述
在我的应用程序中,我有一系列承诺并行访问网络,但有时候,当我的应用程序全速运行时,我的网络速度变慢,由于许多承诺访问网络,我想知道我是怎么做的可以并行控制多少个接入网络。
这是一个代码示例:
in my application, I have and array of promises that access network in parallel, but some times, when my app is running full speed, my network slows down, due to many promises accessing network, I would like to know how I could control how many access network in parallel. This is a sample of code:
var ids = {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 6: 56, 7: 7, 8: 8, 5:6 }; // this is random
Promise.all( Object.keys(ids).map(function(dp){
return new Promise(function(resolve, reject){
http.post({url: addr, form: { data: dp }}, function(err, res, body){
if (err){
reject(err)
}
resolve(body.xx);
});
});
})).then(function(data){
http.post({url: hostAddress, form: { data: data.x }}, function(err, res, body){
......
resolve(body.xx);
});
});
});
}))
有很多网络。我会很棒,我可以同时只允许2或3。感谢您的帮助。
There are a lot of networking. I would be great I could allow only 2 or 3 at the same time. Thanks for your help.
推荐答案
您可以使用 Bluebird的 .map()
,它有一个并发选项来控制有多少请求在飞行中同时:
You can use Bluebird's .map()
which has a concurrency option to control how many requests are in-flight at the same time:
const Promise = require('bluebird');
const http = Promise.promisifyAll(require('http');
var ids = {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 6: 56, 7: 7, 8: 8, 5:6 }; // this is random
Promise.map(Object.keys(ids).map(function(dp){
return http.post({url: addr, form: { data: dp }).then(function(body) {
return body.xx;
});
}), {concurrency: 2}).then(function(results) {
// process results here
});
仅供参考,我不明白你试图用你的第二个 http.post()
做什么,因为你当 data
是一个数组时引用 data.x
的地方。我认为代码有点过多的伪代码说明你真正试图用第二个 http.post()
。
FYI, I didn't understand what you were trying to do with your second http.post()
because you where referencing data.x
when data
is an array. I think the code is a bit too much pseudo-code to illustrate what you were really trying to do with that second http.post()
.
否则,您可以编写自己的并发控制代码,最初启动N个请求,然后每次完成时,启动另一个请求,直到您无需执行任何操作为止这是一个手动编码并发控制的例子:
Otherwise, you can code your own concurrency control where you fire up N requests initially and then each time one finishes, you fire up another until you have no more to do. Here's an example of coding the concurrency control manually:
Fire off 1,000,000 requests 100 at a time
或者,你可以这样自己编写:
Or, you could write it yourself like this:
const http = require('http');
function httpPost(options) {
return new Promise(function(resolve, reject) {
http.post(options, function(err, res, body) {
if (err) {
reject(err);
} else {
resolve(body);
}
});
});
}
// takes an array of items and a function that returns a promise
function mapConcurrent(items, maxConcurrent, fn) {
let index = 0;
let inFlightCntr = 0;
let doneCntr = 0;
let results = new Array(items.length);
let stop = false;
return new Promise(function(resolve, reject) {
function runNext() {
let i = index;
++inFlightCntr;
fn(items[index], index++).then(function(val) {
++doneCntr;
--inFlightCntr;
results[i] = val;
run();
}, function(err) {
// set flag so we don't launch any more requests
stop = true;
reject(err);
});
}
function run() {
// launch as many as we're allowed to
while (!stop && inflightCntr < maxConcurrent && index < items.length) {
runNext();
}
// if all are done, then resolve parent promise with results
if (doneCntr === items.length) {
resolve(results);
}
}
run();
});
}
var ids = {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 6: 56, 7: 7, 8: 8, 5:6 }; // this is random
mapConcurrent(Object.keys(ids), 2, function(item, index) {
return httpPost({url: addr, form: {data: item}}).then(function(body) {
return body.xxx;
});
}).then(function(results) {
// array of results here
}, function(err) {
// error here
});
这篇关于Javascript - 如何控制并行访问网络的承诺数量的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!