几天来，我一直在寻找一个有效的错误解决方案
错误:EMFILE，打开的文件太多
似乎很多人都有同样的问题。通常的答案是增加文件描述符的数量。所以，我试过了:
sysctl -w kern.maxfiles=20480
缺省值为10240。在我看来，这有点奇怪，因为我在目录中处理的文件数量低于10240。更奇怪的是，在增加了文件描述符的数量之后，我仍然收到相同的错误。
第二个问题:
经过多次搜索，我找到了一个解决“打开文件太多”问题的方法:
var requestBatches = {};
function batchingReadFile(filename, callback) {
// First check to see if there is already a batch
if (requestBatches.hasOwnProperty(filename)) {
requestBatches[filename].push(callback);
return;
}
// Otherwise start a new one and make a real request
var batch = requestBatches[filename] = [callback];
FS.readFile(filename, onRealRead);
// Flush out the batch on complete
function onRealRead() {
delete requestBatches[filename];
for (var i = 0, l = batch.length; i < l; i++) {
batch[i].apply(null, arguments);
}
}
}
function printFile(file){
console.log(file);
}
dir = "/Users/xaver/Downloads/xaver/xxx/xxx/"
var files = fs.readdirSync(dir);
for (i in files){
filename = dir + files[i];
console.log(filename);
batchingReadFile(filename, printFile);
不幸的是，我仍然收到相同的错误。
这段代码有什么问题?
以@blak3r的回答为基础，以下是我使用的一些速记，以防它有助于其他诊断:
如果你试图调试一个正在耗尽文件描述符的node .js脚本，这里有一行给你问题节点进程使用的lsof的输出:
openFiles = child_process.execSync(`lsof -p ${process.pid}`);
这将同步运行由当前运行的Node.js进程过滤的lsof，并通过缓冲区返回结果。
然后使用console.log(openFiles.toString())将缓冲区转换为字符串并记录结果。
你读的文件太多了。节点异步读取文件，它会一次读取所有文件。所以你可能读到了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()
像我们所有人一样，您也是异步I/O的另一个受害者。对于异步调用，如果你循环了很多文件，Node.js将开始为每个要读取的文件打开一个文件描述符，然后等待操作，直到关闭它。
文件描述符保持打开状态，直到服务器上的资源可用来读取它。即使您的文件很小，读取或更新很快，也需要一些时间，但与此同时，循环不会停止打开新的文件描述符。所以如果你有太多的文件，限制将很快达到，你会得到一个漂亮的EMFILE。
有一个解决方案，创建一个队列来避免这种影响。
感谢编写Async的人，这里有一个非常有用的函数。有一个方法叫做Async。队列，您将创建一个具有限制的新队列，然后将文件名添加到队列中。
注意:如果你必须打开许多文件，最好存储当前打开的文件，不要无限地重新打开它们。
const fs = require('fs')
const async = require("async")
var q = async.queue(function(task, callback) {
console.log(task.filename);
fs.readFile(task.filename,"utf-8",function (err, data_read) {
callback(err,task.filename,data_read);
}
);
}, 4);
var files = [1,2,3,4,5,6,7,8,9,10]
for (var file in files) {
q.push({filename:file+".txt"}, function (err,filename,res) {
console.log(filename + " read");
});
}
您可以看到每个文件都被添加到队列(console.log文件名)中，但仅当当前队列低于您之前设置的限制时。
异步。队列通过回调获取关于队列可用性的信息，此回调仅在读取数据文件并且实现必须执行的任何操作时调用。(参见fileRead方法)
所以你不会被文件描述符搞得不知所措。
> node ./queue.js
0.txt
1.txt
2.txt
0.txt read
3.txt
3.txt read
4.txt
2.txt read
5.txt
4.txt read
6.txt
5.txt read
7.txt
1.txt read (biggest file than other)
8.txt
6.txt read
9.txt
7.txt read
8.txt read
9.txt read
