在一个限制并发性的池中运行 Promise。
Runs Promises in a pool that limits their concurrency.
An ECMAScript 2015 Promise is a great way to handle asynchronous operations.
The Promise.all function provides an easy interface to let a bunch of promises
settle concurrently.
However, it's an all-or-nothing approach: all your promises get created
simultaneously. If you have a ton of operations that you want to run with some
concurrency, Promise.all is no good.
Instead, you probably want to limit the maximum number of simultaneous operations. That's where this module comes in. It provides an easy way of waiting for any number of promises to settle, while imposing an upper bound on the number of simultaneously executing promises.
The promises can be created in a just-in-time fashion. You essentially pass a function that produces a new promise every time it is called. Alternatively, you can pass an ES2015 iterator, meaning you can also use generator functions.
This module can be used both under Node.js and on the Web. If your
platform does not have a native Promise implementation, you can use a polyfill
such as ES6-Promise.
npm install --save es6-promise-poolbower install --save es6-promise-pool…The PromisePool constructor takes a Promise-producing function as its first
argument. Let's first assume that we have this helper function that returns a
promise for the given value after time milliseconds:
var delayValue = function (value, time) {
return new Promise(function (resolve, reject) {
console.log('Resolving ' + value + ' in ' + time + ' ms')
setTimeout(function () {
console.log('Resolving: ' + value)
resolve(value)
}, time)
})
}Now, let's use the helper function above to create five such promises, which
are each fulfilled after a second. Because of the concurrency of 3, the
first three promises will be fulfilled after one second. Then, the remaining two
will be processed and fulfilled after another second.
var count = 0
var promiseProducer = function () {
if (count console.log('Complete'))It's also possible to pass a generator function directly. In that case, it will be invoked with no arguments and the resulting iterator will be used. This feature will however be removed in version 3.
We can also ask the promise pool to notify us when an individual promise is
fulfilled or rejected. The pool fires fulfilled and rejected events exactly
for this purpose.
…Since version 2.0.0, this module does not depend on
ES6-Promise anymore. If you
want to support platforms without a native Promise implementation, please
load a polyfill first.
If you prefer not to polyfill the global Promise for whatever reason, you can
also pass your Promise class as an option instead:
var ES6Promise = require('es6-promise').Promise // or another implementation
var pool = new PromisePool(promiseProducer, concurrency, {promise: ES6Promise})Promise.map(),
which takes a concurrency option.λ.concurrent()
with the optional cap parameter.queue() function.MIT
暂无开放 Issues,或尚未同步最近议题。