更新

Question

我正在尝试设置一个简单的文档输入器来对ElasticSearch进行基准测试，我选择了NodeJS，因为我认为使用简单的JSON结构最简单。不幸的是，似乎我在脚下射击自己。

以下是相关位：

  var logResults = function (results) {
    docsIndexed++;
    var now = +new Date();
    if (docsIndexed % 10000 === 0) {
      log("Indexed " + docsIndexed + " documents in " + (now - start) + "ms");
    }
  }

  var submitDocument = function (source, index, type) {
    var doc = ejs.Document(index, type).source(source);
    doc.doIndex(logResults);
  }

  var schemas = {};
    _(10).times(function (idx) {
    schemas[pickRandomWord()] = generateRandomDocumentSchema(_.random(idx, 15), 10);
  });

  var docCount = 0, docsIndexed = 0, start = +new Date();
  Object.keys(schemas).forEach(function (schemaName, idx) {
    var register = function () {
      submitDocument(generateRandomDocument(schemas[schemaName]), 
        'documents', schemaName);
      docCount++;
    };
    _((idx + 1) * 1000).times(register);
    log("Registered " + ((idx + 1) * 1000) + " documents for indexing for schema " 
      + schemaName + ". Total: " + docCount);
  });

这适用于最多100 000条记录的数据集，但是如果我要花费数百万，那么内存错误会让我感到震惊。

来自elastic.js的doIndex函数是异步的，我怀疑许多对象在实际执行之前正在排队。当该数字变得重要时，该过程就会死亡。我不明白为什么在循环结束之前没有执行回调。我想要的是一种方法，要么使它同步或为它进行某种池化，以便在发送其他对象之前不排队更多的对象。

有人可以建议一个可以帮助这个或更好的方法来构建代码的库吗？感谢。

更新

我已经尝试过Peter建议使用async.queue，我想出了这个：

  /** Submit QUANT * (idx + 1) documents for each schema into the index */ 
  var QUANT = 100
    , docCount = 0
    , docsIndexed = 0
    , queue = async.queue(submitDocument, 1000)
    , paused = false
    , start = +new Date();

  queue.saturated = function () {
    log("queue is full");
    paused = true;
  };
  queue.empty = function () {
    log("All items were given to workers");
    paused = false; 
  };

  Object.keys(schemas).forEach(function (schemaName, idx) {
    var count = 0;
    while (count < (idx + 1) * QUANT) {
      if (!paused) {
        queue.push({ 
          source: generateRandomDocument(schemas[schemaName]), 
          index: 'documents', 
          type: schemaName 
        });
        count++; docCount++;
      }
    };
    log("Registered " + count + " documents for indexing for schema " 
      + schemaName + ". Total: " + docCount);
  });

如果它在循环中暂停，它会永久挂起（即调用queue.saturated，暂停设置为true，然后程序停留在while循环中）。永远不会调用queue.empty callback。如果我的队列的并发限制高于我想要处理的数字，这可以正常工作 - 所有消息都按预期记录。我应该在这里改变什么？

更新＃2

我已经将代码更改为使用异步循环，现在它可以工作了。我遇到了一个RangeError: Maximum call stack size exceeded错误，我挣扎了一段时间。

  Object.keys(schemas).forEach(function (schemaName, idx) {
    var count = 0, executions = 0;
    async.whilst(
      function () { 
        var test = count < (idx + 1) * QUANT; 
        if (!test) log("Registered " + count + " documents for indexing for schema " 
          + schemaName + ". Executions: " + executions + ". Total: " + docCount);
        return test;
      },

      function (callback) {
        executions++;
        if (!paused) {
          queue.push({ source: generateRandomDocument(schemas[schemaName]), index: 'documents', type: schemaName });
          count++; docCount++;
        }
        setTimeout(callback, 0);
        // also tried with "return process.nextTick(callback)"
        // and return callback();
        // this blows up nicely with an out of memory error
      },
      function (err) {}
    );
  });

我开始感到沮丧，因为我不认为这个用例真的那么复杂，我希望我对语言的运作方式有一个公平的理解。

Answer 1

最好的选择是async.queue，限制很大。只需确保在物品已经饱和后不再将其添加到队列中。使用队列的饱和度作为背压，等待一些工作完成，然后开始排队更多的任务。队列有钩子来支持这些关键事件。

构造NodeJS异步代码，使其更具内存效率

更新

更新＃2

1 个答案: