两个队列，一个具有并发 1，另一个具有并发 3

Question

我遇到这种情况：

const q1 = async.queue((task,cb) => task(cb), 1);
const q2 = async.queue((task,cb) => task(cb), 3);

基本上，情况是 - 如果我可以在 Q1 上锁定，我最多可以在 Q2 中同时处理 3 件事。另外，我的程序中的大多数东西都必须串行运行，但当然可以并行运行，但前提是它们首先在 q1 上获得"锁"。然而，事实证明，写这篇文章比预期的要困难得多。我认为这类似于读取/写入锁定问题。 https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock

换句话说，如果我锁定了 q1，我只能在 q2 中处理事情。实现这一点的一个问题是，如果我总是必须在 q2 的关键部分获取对 q1 的锁定，那么我将无法在 q2 中使用更高的并发级别，它将始终是串行的。

我现在唯一的想法是翻转一个布尔值，如下所示：

let q2HasLock = false;
if(q2hasLock === true){
q2.push(cb => ...);
}
else{
q1.push(cb => ...);
}

那么我可以使用这个：

q2.drain = () => {
q2HasLock = false;
};

但剩下的部分是我不知道如何/何时将q2HasLock翻转到true.希望您了解问题/想法。此实现的另一个问题是，推送到 q2 的请求可能会使将要推送到 q1 的请求匮乏，所以我可以这样做：

let q2HasLock = false, count = 0 ;
if(q2hasLock === true && count < 3){
count++;
q2.push(cb => ...);
}
else{
q1.push(cb => ...);
}
q2.drain = () => {
count = 0;
q2HasLock = false;
};

这越来越毛茸茸的 - 我想尽可能简单地实现这一点！

Answer 1

好的，这应该满足要求，但最好找到一种比这更简单的方法：

const async = require('async');
const q1 = async.queue((task, cb) => task(cb), 1);
const q2 = async.queue((task, cb) => task(cb), 3);
const map = new Map();
let count = 0;
const getProm = function (q) {
if (!map.has(q)) {
map.set(q, new Promise(resolve => {
q1.push(cb => {
resolve();  // 'lock' on q1 has been obtained, nothing can use q1 until we release the lock by calling cb().
q.drain = () => {
q.drain = null;
count = 0;
map.delete(q);
cb();
};
});
}));
}
return map.get(q);
};

if(foo && count < 5){
return getProm(q2).then(v => {
q2.push(cb => {
setTimeout(cb, 140);
});
});
}
return q1.push(cb => {
setTimeout(cb, 30);
});

这样做的是 - 一次只能运行一种类型的任务，但如果任务类型是 Foo，那么 3 个可以同时运行。count < 5检查可确保 q1 请求不会被 q2 请求耗尽。

这里的诀窍是使用承诺。解析承诺后，您仍然可以使用解析值调用promise.then()，尽管在这种情况下我们不需要该值。

对于稍微高一点的性能，我们可以使用布尔标志而不是 promise，但那里的逻辑要多得多。