在我的 node.js 服务器中，我无法弄清楚为什么它会耗尽内存。我的 node.js 服务器为它收到的每个 http 请求发出一个远程 http 请求，因此我尝试使用下面的示例脚本复制问题，该脚本也耗尽了内存。

只有在 for 循环中的迭代次数非常高时才会发生这种情况。

在我看来，问题与 node.js 正在排队远程 http 请求有关。如何避免这种情况？

这是示例脚本:

(function() {
  var http, i, mypost, post_data;
  http = require('http');
  post_data = 'signature=XXX%7CPSFA%7Cxxxxx_value%7CMyclass%7CMysubclass%7CMxxxxx&schedule=schedule_name_6569&company=XXXX';
  mypost = function(post_data, cb) {
    var post_options, req;
    post_options = {
      host: 'myhost.com',
      port: 8000,
      path: '/set_xxxx',
      method: 'POST',
      headers: {
        'Content-Length': post_data.length
      }
    };
    req = http.request(post_options, function(res) {
      var res_data;
      res.setEncoding('utf-8');
      res_data = '';
      res.on('data', function(chunk) {
        return res_data += chunk;
      });
      return res.on('end', function() {
        return cb();
      });
    });
    req.on('error', function(e) {
      return console.debug('TM problem with request: ' + e.message);
    });
    req.write(post_data);
    return req.end;
  };
  for (i = 1; i <= 1000000; i++) {
    mypost(post_data, function() {});
  }
}).call(this);


$ node -v
v0.4.9
$ node sample.js
FATAL ERROR: CALL_AND_RETRY_2 Allocation failed - process out of memory

提前通知

古尔登 PT

最佳答案

限制进入服务器的请求流

可以防止内置 Server 过载通过设置 maxConnections 及其 HTTP/HTTPS 变体实例上的属性。设置此属性将导致 Node 停止 accept()连接并强制操作系统在 listen() 时丢弃请求积压已满，应用程序已在处理 maxConnections请求。

限制传出请求

有时，有必要限制传出请求，如问题中的示例脚本所示。

直接使用 Node 或使用通用池

如问题所示，未经检查直接使用 Node 网络子系统会导致内存不足错误。像 node-pool使主动池管理具有吸引力，但它并没有解决无约束排队的根本问题。原因是 node-pool不提供有关客户端池状态的任何反馈。

更新:从 v1.0.7 开始，node-pool 包含一个受这篇文章启发的补丁，用于将 bool 返回值添加到 acquire() .下一节中的代码不再需要，流模式的示例是使用 Node 池的代码。

破解打开抽象

如 Andrey Sidorov 所示，可以通过显式跟踪队列大小并将排队代码与请求代码混合来获得解决方案:

var useExplicitThrottling = function () {
  var active = 0
  var remaining = 10
  var queueRequests = function () {
    while(active < 2 && --remaining >= 0) {
      active++;
      pool.acquire(function (err, client) {
        if (err) {
          console.log("Error acquiring from pool")
          if (--active < 2) queueRequests()
          return
        }
        console.log("Handling request with client " + client)
        setTimeout(function () {
          pool.release(client)
          if(--active < 2) {
            queueRequests()
          }
        }, 1000)
      })
    }
  }
  queueRequests(10)
  console.log("Finished!")
}

借用流模式

streams模式是 Node 中惯用的解决方案。流有 write返回 false 的操作当流无法缓冲更多数据时。可以使用 acquire() 将相同的模式应用于池对象。返回 false当获得最大数量的客户时。一个 drain当事件客户端的数量低于最大值时发出事件。池抽象再次关闭，可以省略对池大小的显式引用。

var useStreams = function () {
  var queueRequests = function (remaining) {
    var full = false
    pool.once('drain', function() {
        if (remaining) queueRequests(remaining)
    })

    while(!full && --remaining >= 0) {
      console.log("Sending request...")
      full = !pool.acquire(function (err, client) {
        if (err) {
          console.log("Error acquiring from pool")
          return
        }
        console.log("Handling request with client " + client)
        setTimeout(pool.release, 1000, client)
      })
    }
  }
  queueRequests(10)
  console.log("Finished!")
}

纤维

可以通过在队列顶部提供阻塞抽象来获得替代解决方案。 fibers 模块暴露 coroutines用 C++ 实现的。通过使用纤程，可以在不阻塞 Node 事件循环的情况下阻塞执行上下文。虽然我发现这种方法非常优雅，但它在 Node 社区中经常被忽视，因为它对所有看起来同步的东西都有一种奇怪的反感。请注意，不包括 callcc实用程序，实际的循环逻辑非常简洁。

/* This is the call-with-current-continuation found in Scheme and other
 * Lisps. It captures the current call context and passes a callback to
 * resume it as an argument to the function. Here, I've modified it to fit
 * JavaScript and node.js paradigms by making it a method on Function
 * objects and using function (err, result) style callbacks.
 */
Function.prototype.callcc = function(context  /* args... */) {
  var that = this,
      caller = Fiber.current,
      fiber = Fiber(function () {
        that.apply(context, Array.prototype.slice.call(arguments, 1).concat(
          function (err, result) {
            if (err)
              caller.throwInto(err)
            else
              caller.run(result)
          }
        ))
      })
  process.nextTick(fiber.run.bind(fiber))
  return Fiber.yield()
}

var useFibers = function () {
  var remaining = 10
  while(--remaining >= 0) {
    console.log("Sending request...")
    try {
      client = pool.acquire.callcc(this)
      console.log("Handling request with client " + client);
      setTimeout(pool.release, 1000, client)
    } catch (x) {
      console.log("Error acquiring from pool")
    }
  }
  console.log("Finished!")
}

结论

有许多解决问题的正确方法。但是，对于需要在许多上下文中共享单个池的库作者或应用程序，最好正确封装该池。这样做有助于防止错误并生成更清晰、更模块化的代码。防止不受约束的排队然后变成事件舞蹈或协程模式。我希望这个答案能消除很多关于阻塞式代码和异步行为的 FUD 和困惑，并鼓励您编写让您开心的代码。

关于http.request 循环中的 node.js 进程内存不足，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6623683/