两个队列，一个并发 1 另一个并发 3答案

【问题标题】：Two queues, one with concurrency 1 another with concurrency 3两个队列，一个并发 1 另一个并发 3
【发布时间】：2023-04-09 09:14:01
【问题描述】：

我有这种情况：

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

基本上，情况是 - 如果我可以锁定 q1，我可以在 q2 中同时处理多达 3 件事情。 Aka，我程序中的大多数东西都必须串行运行，但当然可以并行运行，但前提是它们首先在 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;
};

这有点麻烦 - 我想尽可能简单地实现它！

【问题讨论】：

能否请您详细说明队列将执行什么样的任务？你可能知道，JS 是单线程的，除了委托给libuv 的 theadpool 的任何异步操作，如文件或网络 I/O，默认设置为 4。这意味着 Node 无法运行并行执行超过 4 个异步操作，除非您更改 UV_THREADPOOL_SIZE 环境变量。在单线程环境中不需要像 Mutexes（这就是这个锁）这样的同步原语。
大部分队列任务都会做异步 I/O，是的

标签： javascript node.js concurrency queue async.js

【解决方案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 被解决，你仍然可以调用 promise.then()，并使用分辨率值，尽管在这种情况下我们不需要该值。

为了稍微提高性能，我们可以使用布尔标志而不是承诺，但那里的逻辑要复杂得多。

【讨论】：