Question

我遇到了一个自定义异步队列的错误，该队列一次调用10个异步函数。

我正在使用50个作业启动队列，一旦完成前10个作业，队列就会移动到后续10个作业，直到完成所有作业。

我遇到的错误是，一旦完成50，它会重新开始，前5个作业一次只能处理2个或3个或1个作业。在队列结束时，它还需要不到10个作业。

请创建这两个文件并使用mocha进行测试并亲自查看输出。

注意：将mocha中的超时设置为0，以使测试长时间保持运行。

Queue.js

function Queue(func, max) {
    this.jobs = [];
    this.func = func;
    this.max = max ? max : 10;
}

Queue.prototype.push = function(data) {
    var self = this;
    return new Promise(function(resolve, reject){
        self.jobs.push({data: data, resolve: resolve, reject: reject});
        if(!self.progress) {
            self.progress = true;
            self.run();
        }
    });
};

Queue.prototype.run = function() {
    var self = this;
    var tasks = [];

    console.log("--------------------");

    for(var i=0; i<this.jobs.length && i < this.max; i++) {
        tasks.push(this.jobs.shift());
        console.log("queuing", tasks[tasks.length-1].data);
    }
    console.log("Total jobs queued", tasks.length);

    Promise.all(
        tasks.map(function(task){
            return self.func(task.data)
                .then(task.resolve, task.reject);
        }
    )).then(this.next.bind(this));
};

Queue.prototype.next = function(){
    if(this.jobs.length) {
        this.run();
    } else {
        this.progress = false;
    }
};

module.exports = Queue;

QueueTest.js

function async(data) {
    return new Promise(function(resolve, reject){
        setTimeout(function(){
            console.log("resolving", data);
            resolve(data);
        }, Math.random() * 5000);
    });
}

it("should test queue", function(done){
    var queue = new Queue(async);
    Promise.all(
        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
            30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50].map(queue.push.bind(queue))
    ).then(function(){
        done();
    });
});

Answer 1

问题在于for中的Queue.prototype.run循环。

我无法立即明白为什么它应该采用错误行为，但修复方法是将for循环替换为self.jobs.splice()以创建tasks数组。

Queue.prototype.run = function() {
    console.log("--------------------");
    var self = this;
    var tasks = self.jobs.splice(0, self.max); // <<<<<<<< this is the fix
    console.log("tasks:", tasks.map(obj => obj.data));

    Promise.all(
        tasks.map(function(task){
            return self.func(task.data)
            .then(task.resolve, task.reject);
        }
    )).then(this.next.bind(this));
};

没有其他事情需要改变。

Answer 2

问题是 for 循环中的这个条件：i<this.jobs.length

i 正在计算批处理中计划的作业数。当 i 是作业数组中的索引时，此条件是正确的。在这种情况下，我们只想确认还有待处理的作业，因此我们可以简单地使用：this.jobs.length>0

队列末尾的奇怪行为是因为随着元素从作业数组中移出，长度正在下降，但在该批次 (i) 中调度的作业数量正在增加。我们以进入for循环时this.jobs.length为4的例子为例：

<头>

我	this.jobs.length	i
0	4	真实
1	3	真实
2	2	假

在这种情况下，仅在队列中的四个作业中调度了 2 个后退出循环。检查是否还有剩余任务可以解决问题：

for(var i=0; this.jobs.length > 0 && i < this.max; i++) {

具有最大并发性的异步并发队列

2 个答案: