当优雅的 fs不起作用时……或者您只想了解泄漏的来源。按照这个过程。

（例如，如果您的问题与套接字有关，graceful-fs 不会修复您的旅行车。）

来自我的博客文章：http : //www.blakerobertson.com/devlog/2014/1/11/how-to-determine-whats-causing-error-connect-emfile-nodejs.html

如何隔离

此命令将输出 nodejs 进程的打开句柄数：

lsof -i -n -P | grep nodejs

COMMAND     PID    USER   FD   TYPE    DEVICE SIZE/OFF NODE NAME
...
nodejs    12211    root 1012u  IPv4 151317015      0t0  TCP 10.101.42.209:40371->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1013u  IPv4 151279902      0t0  TCP 10.101.42.209:43656->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1014u  IPv4 151317016      0t0  TCP 10.101.42.209:34450->54.236.3.168:80 (ESTABLISHED)
nodejs    12211    root 1015u  IPv4 151289728      0t0  TCP 10.101.42.209:52691->54.236.3.173:80 (ESTABLISHED)
nodejs    12211    root 1016u  IPv4 151305607      0t0  TCP 10.101.42.209:47707->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1017u  IPv4 151289730      0t0  TCP 10.101.42.209:45423->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1018u  IPv4 151289731      0t0  TCP 10.101.42.209:36090->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1019u  IPv4 151314874      0t0  TCP 10.101.42.209:49176->54.236.3.172:80 (ESTABLISHED)
nodejs    12211    root 1020u  IPv4 151289768      0t0  TCP 10.101.42.209:45427->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1021u  IPv4 151289769      0t0  TCP 10.101.42.209:36094->54.236.3.170:80 (ESTABLISHED)
nodejs    12211    root 1022u  IPv4 151279903      0t0  TCP 10.101.42.209:43836->54.236.3.171:80 (ESTABLISHED)
nodejs    12211    root 1023u  IPv4 151281403      0t0  TCP 10.101.42.209:43930->54.236.3.172:80 (ESTABLISHED)
....

请注意： 1023u（最后一行） - 这是默认最大值的第 1024 个文件句柄。

现在，看看最后一列。这表明哪个资源是开放的。您可能会看到许多行都具有相同的资源名称。希望现在可以告诉您在代码中查找泄漏的位置。

如果你不知道多个节点进程，首先查找哪个进程有pid 12211。它会告诉你进程。

在我上面的例子中，我注意到有一堆非常相似的 IP 地址。他们都是54.236.3.### 通过进行 ip 地址查找，能够确定在我的情况下它与 pubnub 相关。

命令参考

使用此语法来确定进程打开了多少个打开的句柄...

获取某个 pid 的打开文件数

我使用此命令来测试在我的应用程序中执行各种事件后打开的文件数。

lsof -i -n -P | grep "8465" | wc -l

# lsof -i -n -P | grep "nodejs.*8465" | wc -l
28
# lsof -i -n -P | grep "nodejs.*8465" | wc -l
31
# lsof -i -n -P | grep "nodejs.*8465" | wc -l
34

你的进程限制是多少？

ulimit -a

您想要的行将如下所示：

open files                      (-n) 1024

永久更改限制：

• 在 Ubuntu 14.04、nodejs v. 7.9 上测试

如果您希望打开许多连接（websockets 就是一个很好的例子），您可以永久增加限制：

• 文件：/etc/pam.d/common-session （添加到最后）

    session required pam_limits.so
  

• 文件：/etc/security/limits.conf （添加到最后，如果已经存在则编辑）

    root soft  nofile 40000
    root hard  nofile 100000
  

• 重新启动您的 nodejs 并从 ssh 注销/登录。

• 这可能不适用于较旧的 NodeJS，您需要重新启动服务器

• 如果您的节点使用不同的 uid 运行，请使用代替。

使用graceful-fsIsaac Schlueter（node.js 维护者）的module可能是最合适的解决方案。如果遇到 EMFILE，它会进行增量回退。它可以用作内置fsmodule的直接替代品。

我不确定这是否会帮助任何人，我开始从事一个有很多依赖项的大项目，这给我带来了同样的错误。我的同事建议我watchman使用 brew安装，这为我解决了这个问题。

brew update
brew install watchman

2019 年 6 月 26 日编辑： Github 链接到守望者

您正在阅读太多文件。节点异步读取文件，它将一次读取所有文件。因此，您可能正在阅读 10240 限制。

看看这是否有效：

var fs = require('fs')
var events = require('events')
var util = require('util')
var path = require('path')

var FsPool = module.exports = function(dir) {
    events.EventEmitter.call(this)
    this.dir = dir;
    this.files = [];
    this.active = [];
    this.threads = 1;
    this.on('run', this.runQuta.bind(this))
};
// So will act like an event emitter
util.inherits(FsPool, events.EventEmitter);

FsPool.prototype.runQuta = function() {
    if(this.files.length === 0 && this.active.length === 0) {
        return this.emit('done');
    }
    if(this.active.length < this.threads) {
        var name = this.files.shift()

        this.active.push(name)
        var fileName = path.join(this.dir, name);
        var self = this;
        fs.stat(fileName, function(err, stats) {
            if(err)
                throw err;
            if(stats.isFile()) {
                fs.readFile(fileName, function(err, data) {
                    if(err)
                        throw err;
                    self.active.splice(self.active.indexOf(name), 1)
                    self.emit('file', name, data);
                    self.emit('run');

                });
            } else {
                self.active.splice(self.active.indexOf(name), 1)
                self.emit('dir', name);
                self.emit('run');
            }
        });
    }
    return this
};
FsPool.prototype.init = function() {
    var dir = this.dir;
    var self = this;
    fs.readdir(dir, function(err, files) {
        if(err)
            throw err;
        self.files = files
        self.emit('run');
    })
    return this
};
var fsPool = new FsPool(__dirname)

fsPool.on('file', function(fileName, fileData) {
    console.log('file name: ' + fileName)
    console.log('file data: ', fileData.toString('utf8'))

})
fsPool.on('dir', function(dirName) {
    console.log('dir name: ' + dirName)

})
fsPool.on('done', function() {
    console.log('done')
});
fsPool.init()

我今天遇到了这个问题，并没有找到好的解决方案，我创建了一个module来解决它。我受到@fbartho 片段的启发，但想避免覆盖 fs module。

我写的module是Filequeue，你可以像 fs 一样使用它：

var Filequeue = require('filequeue');
var fq = new Filequeue(200); // max number of files to open at once

fq.readdir('/Users/xaver/Downloads/xaver/xxx/xxx/', function(err, files) {
    if(err) {
        throw err;
    }
    files.forEach(function(file) {
        fq.readFile('/Users/xaver/Downloads/xaver/xxx/xxx/' + file, function(err, data) {
            // do something here
        }
    });
});