Jaki jest najlepszy sposób ograniczenia współbieżności przy użyciu opcji Promise.all() ES6?

Question

Mam pewien kod, który jest iteracją na liście, która została przeszukiwana z bazy danych i wysyła żądanie HTTP dla każdego elementu na tej liście. Lista ta może czasami być dość dużą liczbą (w tysiącach) i chciałbym się upewnić, że nie trafię na serwer WWW z tysiącami równoczesnych żądań HTTP.

skrócona wersja tego kodu aktualnie wygląda tak ...

function getCounts() { 
    return users.map(user => { 
    return new Promise(resolve => { 
     remoteServer.getCount(user) // makes an HTTP request 
     .then(() => { 
     /* snip */ 
     resolve(); 
     }); 
    }); 
    }); 
} 

Promise.all(getCounts()).then(() => { /* snip */}); 

Ten kod jest uruchomiony na węźle 4.3.2. Aby powtórzyć, czy można zarządzać Promise.all, tak aby w danym momencie realizowana była tylko określona liczba obietnic?

Answer 1

Należy pamiętać, że Promise.all() nie uruchamia obietnic rozpoczęcia pracy, ponieważ sama tworzy obietnicę.

Mając to na uwadze, jednym z rozwiązań byłoby sprawdzenie, czy obietnica zostanie rozstrzygnięta, czy nowa obietnica powinna zostać uruchomiona, czy też już znajduje się na granicy.

Jednak nie ma potrzeby wymyślać na nowo koła. One library that you could use for this purpose is es6-promise-pool. Z ich przykładów:

// On the Web, leave out this line and use the script tag above instead. 
var PromisePool = require('es6-promise-pool') 

var promiseProducer = function() { 
    // Your code goes here. 
    // If there is work left to be done, return the next work item as a promise. 
    // Otherwise, return null to indicate that all promises have been created. 
    // Scroll down for an example. 
} 

// The number of promises to process simultaneously. 
var concurrency = 3 

// Create a pool. 
var pool = new PromisePool(promiseProducer, concurrency) 

// Start the pool. 
var poolPromise = pool.start() 

// Wait for the pool to settle. 
poolPromise.then(function() { 
    console.log('All promises fulfilled') 
}, function (error) { 
    console.log('Some promise rejected: ' + error.message) 
}) 

Answer 2

Zamiast używać obietnic dla ograniczenia żądań HTTP, korzystanie węzeł wbudowanej http.Agent.maxSockets. Eliminuje to konieczność korzystania z biblioteki lub pisania własnego kodu łączącego i ma dodatkową zaletę większą kontrolę nad tym, co ograniczasz.

agent.maxSockets

domyślnie ustawiony na nieskończoność. Określa, ile równoczesnych gniazd może otwierać agent na początek. Origin jest kombinacją "host: port" lub "host: port: localAddress".

Na przykład:

var http = require('http'); 
var agent = new http.Agent({maxSockets: 5}); // 5 concurrent connections per origin 
var request = http.request({..., agent: agent}, ...); 

przypadku wykonywania wielu żądań do tego samego pochodzenia, może również korzystać na ustawienie keepAlive true (patrz powyższe dokumenty aby uzyskać więcej informacji).

Answer 3

Bluebird's Promise.map może wybrać opcję współbieżności, aby kontrolować, ile obietnic powinno być uruchomionych równolegle. Czasami jest to łatwiejsze niż .all, ponieważ nie trzeba tworzyć tablicy obietnicy.

const Promise = require('bluebird') 

function getCounts() { 
    return Promise.map(users, user => { 
    return new Promise(resolve => { 
     remoteServer.getCount(user) // makes an HTTP request 
     .then(() => { 
     /* snip */ 
     resolve(); 
     }); 
    }); 
    }, {concurrency: 10}); // <---- at most 10 http requests at a time 
} 

ref: http://bluebirdjs.com/docs/api/promise.map.html