按顺序运行大量的承诺

Question

一个nodejs项目。我试着用承诺运行大量（大约100k）任务。我可以做的是将它转换为Q的workOnebyOne函数。有没有更好的方法来做到这一点？

function workOnebyOne(items, worker) { 
    var deferred = Q.defer() 

    function _doNext() { 
    if (items.length === 0) { 
     deferred.resolve() 
     return 
    } 
    var item = items[0] 
    synchronize(worker, item) 
     .then(function (result) { 
     items = items.slice(1) 
     deferred.notify({ 
      item: item, 
      result: result 
     }) 
     _doNext() 
     }, function() { 
     items = items.slice(1) 
     _doNext() 
     }) 
    } 

    _doNext() 

    return deferred.promise 
} 

utils.workOnebyOne(tasks, workerFunction) 

Answer 1

你基本上是在这里重新实施排队。在蓝鸟承诺（这也是更快，消耗更少的内存，这有助于100K任务），你会使用Promise.each。

在Q中，您通常可以在任务数组上使用.reduce将它们一次排队 - 然而，使用100K元素在Q promise中创建100K承诺队列会导致节点崩溃（同样，这是Q，蓝鸟或承诺时）它就好）。这（这里不正确）解决方案看起来是这样的：

var res = tasks.reduce(function(p, c){ 
    return p.then(function(){ return workerFunction(c); }); 
}, Q()); 

对于短队列（< 500许诺Q）这工作得很好。

因此，由于旧的图书馆的选择，并且由于涉及大量的承诺，您不能现实地解决它的优雅，使用类似回调队列的方法非常接近您唯一的方式。我也避免notify，因为它被删除（甚至从Q），并且通常是一个糟糕的API（编写不好）。

Answer 2

我花了一些时间寻找简单而优雅的解决方案。我发现只有一些提示和讨论，但没有现成的例子。最后，我发现在https://github.com/kriskowal/q/issues/606，结果什么都为我工作可以分离和推广这样的讨论：

function workOneByOne(items, someAsyncFuntionReturningPromise) { 
    var lastResultPromise = items 
    .map(function(item) { 
     return function(previousResult) { 
     /* 
     * this function has to: 
     * - process result from previous item processed if any 
     * - call the async job 
     * - return promise of the job done 
     */ 
     if (previousResult) { 
      // process result here 
     } 

     return someAsyncFuntionReturningPromise(item); 
    }}) 
    .reduce(Q.when, Q()); 

    return lastResultPromise; 
} 

并且如果没有可用的函数返回的承诺，你可以拨打上面

workOneByOne(items, Q.nfbind(someAsyncFunctionWithCallback))