如何使用 NodeJS 将 100 万个域名正确解析为 IP 地址？

Question

如何优化以下 NodeJS 代码以异步方式工作并快速运行？我想堆栈变得太大，导致程序变慢并最终崩溃。有没有更好的方法来解析下面的示例中的大量域名？

const dns = require('dns');
const os = require('os');

var logical_cores = os.cpus().length;
console.log(`Logical cores: ${logical_cores}`);
process.env.UV_THREADPOOL_SIZE=logical_cores;

domainToIp_resolve = (domain) => {
  return new Promise((resolve, reject) => {
    // does not use libuv thread pool; uses os async polling 
        dns.resolve(domain, 'A', (err, records) => {
      if (err) {
        reject(`${String(domain).toUpperCase()} | ERROR CODE: ${err.code} |  ERROR MESSAGE: ${err.message}`);
      } else {
        resolve(`${domain}: records: ${records}`);
      }
    });
  });
}

// simulating getting domain names from a list
function* getDomains(num) {
  let cnt = 0;

  for (let ctr = 1; ctr < num+1; ctr++) {

    // 97 = "a"; 123 = "z"
    for (let charCode = 97; charCode < 123; charCode++) {

      let prefix = '';
      for (let p = 0; p < ctr; p++) {
        prefix += `${String.fromCharCode(charCode)}`;
      }

      if (cnt === num) {
        return null;
      } else {
        cnt += 1;
        let domain = `${prefix}.com`;
        yield domain;
      }
    }
  }
}

function resolveDomain(num) {
  let doms = getDomains(num);

  function resolve(cnt, domain) {
    if (cnt < 1) return;
    if (cnt === num) return;

    domainToIp_resolve(domain)
      .then((data) => {
        console.log(data);
      })
      .catch((err) => {
        console.log(err);
      });

    setImmediate(resolve.bind(null, cnt+1, doms.next().value));
  }

  resolve(1, doms.next().value);
}

resolveDomain(1000000);

Answer 1

正如 cmets 中提到的，问题不在于您的程序速度不快。问题是它太快了：你试图并行打开 100 万个套接字。即使您的操作系统允许，您的路由器也不会喜欢它，并且根据下载种子的经验，如果它是消费级家用路由器，您的路由器可能会崩溃。

我们可以通过使用 async/await 来修复它。第一步 - 一次发出一个请求，就像在 PHP 或 Java 等其他语言中一样：

async function resolveDomain(num) { // mark as async so we can use await
  let doms = getDomains(num);

  for (domain of doms) {
    try {
      let data = await domainToIp_resolve(domain);
      console.log(data);
    }
    catch(err) {
      console.log(err);
    }
  }
}

这应该可以，但是会很慢。现在我们可以通过批处理请求来加快速度（我在这里并行处理 20 个，但您可以微调这个数字）：

async function resolveDomain(num) { // mark as async so we can use await
  let doms = getDomains(num);
  let count = 0;
  const BATCH_SIZE = 20;

  while (count < num) {
    try {
      let promises = [];
      for (let i=0;i<BATCH_SIZE && count<num;i++,count++) {
        promises.push(domainToIp_resolve(doms.next().value));
      }

      let result = await Promise.all(promises);
      for (let i=0;i<result.length;i++) {
        console.log(result[i]);
      }
    }
    catch(err) {
      console.log(err);
    }
  }
}

使用 async/await 并不是绝对必要的。您可以使用回调重写上述逻辑，但它会变得复杂。对于这样的逻辑，使用 async/await 会更容易。

请注意，如果我们不关心按请求顺序记录结果，我们可以通过在整个批处理完成之前启动新请求来进一步优化代码。我把它作为家庭作业（提示：async-q 库有一个你可以使用的实现，它甚至可以按顺序返回结果）