以下的Typescript每次只对doSomething(action)执行一次调用。 （这意味着列表中的第二项在完成第一项之前不会进行调用。）
async performActionsOneAtATime() {
for (let action of listOfActions) {
const actionResult = await doSomethingOnServer(action);
console.log(`Action Done: ${actionResult}`);
}
}
这个会立即将所有请求发送到服务器（无需等待任何响应）：
async performActionsInParallel() {
for (let action of listOfActions) {
const actionResultPromise = doSomething(action);
actionResultPromise.then((actionResult) => {
console.log(`Action Done: ${actionResult}`);
});
}
}
但我真正需要的是一种限制它们的方法。也许一次打开10或20个电话。 （一次一个太慢，但所有600都会使服务器超载。）
但我很难搞清楚这一点。
有关如何限制每次打开X的通话次数的任何建议吗？
（这个问题使用TypeScript，但我对ES6 JavaScript答案没问题。）
答案 0 :(得分：7)
您可以在一个简短的功能中执行此操作。 （更新：按照naomik的建议按顺序返回值。）
/**
* Performs a list of callable actions (promise factories) so that only a limited
* number of promises are pending at any given time.
*
* @param listOfCallableActions An array of callable functions, which should
* return promises.
* @param limit The maximum number of promises to have pending at once.
* @returns A Promise that resolves to the full list of values when everything is done.
*/
function throttleActions(listOfCallableActions, limit) {
// We'll need to store which is the next promise in the list.
let i = 0;
let resultArray = new Array(listOfCallableActions.length);
// Now define what happens when any of the actions completes. Javascript is
// (mostly) single-threaded, so only one completion handler will call at a
// given time. Because we return doNextAction, the Promise chain continues as
// long as there's an action left in the list.
function doNextAction() {
if (i < listOfCallableActions.length) {
// Save the current value of i, so we can put the result in the right place
let actionIndex = i++;
let nextAction = listOfCallableActions[actionIndex];
return Promise.resolve(nextAction())
.then(result => { // Save results to the correct array index.
resultArray[actionIndex] = result;
return;
}).then(doNextAction);
}
}
// Now start up the original <limit> number of promises.
// i advances in calls to doNextAction.
let listOfPromises = [];
while (i < limit && i < listOfCallableActions.length) {
listOfPromises.push(doNextAction());
}
return Promise.all(listOfPromises).then(() => resultArray);
}
// Test harness:
function delay(name, ms) {
return new Promise((resolve, reject) => setTimeout(function() {
console.log(name);
resolve(name);
}, ms));
}
var ps = [];
for (let i = 0; i < 10; i++) {
ps.push(() => delay("promise " + i, Math.random() * 3000));
}
throttleActions(ps, 3).then(result => console.log(result));
答案 1 :(得分：3)
Jeff Bowman大大提高了他解决有意义价值的答案。请随意查看此答案的历史记录，以了解为什么已解析的值非常重要/有用。
此解决方案非常类似于原生Promise.all
它是如何相同的......
它有何不同......
// throttlep :: Number -> [(* -> Promise)]
const throttlep = n=> Ps=>
new Promise ((pass, fail)=> {
// r is the number of promises, xs is final resolved value
let r = Ps.length, xs = []
// decrement r, save the resolved value in position i, run the next promise
let next = i=> x=> (r--, xs[i] = x, run(Ps[n], n++))
// if r is 0, we can resolve the final value xs, otherwise chain next
let run = (P,i)=> r === 0 ? pass(xs) : P().then(next(i), fail)
// initialize by running the first n promises
Ps.slice(0,n).forEach(run)
})
// -----------------------------------------------------
// make sure it works
// delay :: (String, Number) -> (* -> Promise)
const delay = (id, ms)=>
new Promise (pass=> {
console.log (`running: ${id}`)
setTimeout(pass, ms, id)
})
// ps :: [(* -> Promise)]
let ps = new Array(10)
for (let i = 0; i < 10; i++) {
ps[i] = () => delay(i, Math.random() * 3000)
}
// run a limit of 3 promises in parallel
// the first error will reject the entire pool
throttlep (3) (ps) .then (
xs => console.log ('result:', xs),
err=> console.log ('error:', err.message)
)
输入按顺序运行;已解决的结果与输入的顺序相同
running: 0
running: 1
running: 2
=> Promise {}
running: 3
running: 4
running: 5
running: 6
running: 7
running: 8
running: 9
result: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
让我们看一个更实用的代码示例。此代码的任务是从服务器获取一组图像。这就是我们如何使用throttlep来同时限制同时发出3个请求的数量
// getImage :: String -> Promise<base64>
let getImage = url=> makeRequest(url).then(data => data.base64, reqErrorHandler)
// actions :: [(* -> Promise<base64>)]
let actions = [
()=> getImage('one.jpg'),
()=> getImage('two.jpg'),
()=> getImage('three.jpg'),
()=> getImage('four.jpg'),
()=> getImage('five.jpg')
]
// throttle the actions then do something...
throttlep (3) (actions) .then(results => {
// results are guaranteed to be ordered the same as the input array
console.log(results)
// [<base64>, <base64>, <base64>, <base64>, <base64>]
})
答案 2 :(得分：2)
没有任何内置功能，因此您必须自己构建。 AFAIK，还没有这个库。
首先，从＆＃34;延期＆＃34;开始 - 允许外部代码解析它的承诺：
class Deferral<T> {
constructor() {
this.promise = new Promise<T>((resolve, reject) => {
this.resolve = resolve;
this.reject = reject;
});
}
promise: Promise<T>;
resolve: (thenableOrResult?: T | PromiseLike<T>) => void;
reject: (error: any) => void;
}
然后你可以定义一个＆＃34;等待队列＆＃34;，它代表所有等待进入临界区的代码块：
class WaitQueue<T> {
private deferrals: Deferral<T>[];
constructor() {
this.deferrals = [];
}
get isEmpty(): boolean {
return this.deferrals.length === 0;
}
enqueue(): Promise<T> {
const deferral = new Deferral<T>();
this.deferrals.push(deferral);
return deferral.promise;
}
dequeue(result?: T) {
const deferral = this.deferrals.shift();
deferral.resolve(result);
}
}
最后，您可以定义一个异步信号量：
export class AsyncSemaphore {
private queue: WaitQueue<void>;
private _count: number;
constructor(count: number = 0) {
this.queue = new WaitQueue<void>();
this._count = count;
}
get count(): number { return this._count; }
waitAsync(): Promise<void> {
if (this._count !== 0) {
--this._count;
return Promise.resolve();
}
return this.queue.enqueue();
}
release(value: number = 1) {
while (value !== 0 && !this.queue.isEmpty) {
this.queue.dequeue();
--value;
}
this._count += value;
}
}
使用示例：
async function performActionsInParallel() {
const semaphore = new AsyncSemaphore(10);
const listOfActions = [...];
const promises = listOfActions.map(async (action) => {
await semaphore.waitAsync();
try {
await doSomething(action);
}
finally {
semaphore.release();
}
});
const results = await Promise.all(promises);
}
此方法首先创建一个throttler，然后立即启动所有异步操作。每个异步操作将首先（异步）等待信号量空闲，然后执行操作，最后释放信号量（允许另一个信号量）。完成所有异步操作后，将检索所有结果。
警告：此代码100％完全未经测试。我甚至没试过一次。
答案 3 :(得分：0)
您可以使用pub-sub模式执行此操作。我也不熟悉typescipt，我不知道这是在浏览器中还是在后端发生的。我将为此编写伪代码（假设它是后端）：
//I'm assuming required packages are included e.g. events = require("events");
let limit = 10;
let emitter = new events.EventEmitter();
for(let i=0; i<limit; i++){
fetchNext(listOfActions.pop());
}
function fetchNext(action){
const actionResultPromise = doSomething(action);
actionResultPromise.then((actionResult) => {
console.log(`Action Done: ${actionResult}`);
emitter.emit('grabTheNextOne', listOfActions.pop());
});
}
emitter.on('grabTheNextOne', fetchNext);
如果您在Node中工作，EventEmitter是NodeJS的一部分。如果在浏览器中，您可以使用正常事件模型。这里的关键想法是Publish-Subscribe模式。
答案 4 :(得分：0)
可以用生成器节流Promises。在下面的示例中，我们对它们进行了限制，以便
function asyncTask(duration = 1000) {
return new Promise(resolve => {
setTimeout(resolve, duration, duration)
})
}
async function main() {
const items = Array(10).fill(() => asyncTask()) {
const generator = batchThrottle(3, ...items)
console.log('batch', (await generator.next()).value)
for await (let result of generator) {
console.log('remaining batch', result)
}
}
{
const generator = streamThrottle(3, ...items)
console.log('stream', await generator.next())
for await (let result of generator) {
console.log('remaining stream', result)
}
}
}
async function* batchThrottle(n = 5, ...items) {
while (items.length) {
const tasks = items.splice(0, n).map(fn => fn())
yield Promise.all(tasks)
}
}
async function* streamThrottle(n = 5, ...items) {
while (items.length) {
const tasks = items.splice(0, n).map(fn => fn())
yield* await Promise.all(tasks)
}
}
main().catch()
答案 5 :(得分：0)
这是一个使用 async await 语法的节流函数版本：
async function throttle(tasks, max) {
async function run(_, i) {
values[i] = await tasks[i]();
if (max < tasks.length) return run(_, max++);
};
const values = [];
try {
await Promise.all(tasks.slice(0, max).map(run));
} catch (error) {
max = tasks.length; // don't allow new tasks to start
throw error;
}
return values;
}
// Demo
const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
const tasks = Array.from({length: 10}, (_, i) =>
async () => {
console.log(`task ${i} starts`);
await delay((1 + i % 3)*1000);
console.log(`task ${i} ends with ${i*10}`);
return i*10;
}
);
throttle(tasks, 4).then(console.log);