Question

我们正在编写一个脚本，在我们的服务器上读取大量JPG文件（无限，因为我们有另一个将JPG文件写入同一目录的进程）并将它们作为MJPEG流发送到用户的浏览器时间间隔（下面代码中的变量“frameDelay”）。这类似于IP摄像机的功能。

我们发现这个脚本的内存使用率不断上升，最终被系统杀死（Ubuntu）;

我们多次检查这个看似简单的脚本。因此我发布下面的代码。任何意见/建议都非常感谢！

app.get('/stream', function (req, res) {
    res.writeHead(200, {
        'Content-Type':'multipart/x-mixed-replace;boundary="' + boundary + '"',
        'Transfer-Encoding':'none',
        'Connection':'keep-alive',
        'Expires':'Fri, 01 Jan 1990 00:00:00 GMT',
        'Cache-Control':'no-cache, no-store, max-age=0, must-revalidate',
        'Pragma':'no-cache'
    });
res.write(CRLF + "--" + boundary + CRLF);

setInterval(function () {
    if(fileList.length<=1){
        fileList = fs.readdirSync(location).sort();
    }else{
        var fname = fileList.shift();
        if(fs.existsSync(location+fname)){
           var data = fs.readFileSync(location+fname);
            res.write('Content-Type:image/jpeg' + CRLF + 'Content-Length: ' + data.length + CRLF + CRLF);
            res.write(data);
            res.write(CRLF + '--' + boundary + CRLF);                   
            fs.unlinkSync(location+fname);
        }else{
            console.log("File doesn't find")
        }
    }
        console.log("new response:" + fname);
    }, frameDelay);
});

app.listen(port);
console.log("Server running at port " + port);

为方便故障排除过程，下面是一个独立的（没有第三方lib）测试用例。

它具有完全相同的内存问题（内存使用量持续上升并最终被操作系统杀死）。

我们认为问题出在setInterval（）循环中 - 也许这些图像在发送后没有从内存中删除或者某些东西（可能仍然存储在变量“res”中？）。

非常感谢任何反馈/建议！

var http                = require('http');
var fs                  = require('fs');

var framedelay  = 40;
var port                = 3200;
var boundary    = 'myboundary';
var CR                  = '\r';
var LF                  = '\n';
var CRLF                = CR + LF;

function writeHttpHeader(res)
{
        res.writeHead(200,
        {
                'Content-Type': 'multipart/x-mixed-replace;boundary="' + boundary + '"',
                'Transfer-Encoding': 'none',
                'Connection': 'keep-alive',
                'Expires': 'Fri, 01 Jan 1990 00:00:00 GMT',
               'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate',
                'Pragma': 'no-cache',
        });

        res.write(CRLF + '--' + boundary + CRLF);
}

function writeJpegFrame(res, filename)
{
        fs.readFile('./videos-8081/frames/' + filename, function(err, data)
        {
                if (err)
                {
                        console.log(err);
                }
                else
                {
                        res.write('Content-Type:image/jpeg' + CRLF);
                        res.write('Content-Length:' + data.length + CRLF + CRLF);
                            res.write(data);
                        res.write(CRLF + '--' + boundary + CRLF);
                        console.log('Sent ' + filename);
                }
        });
}
http.createServer(function(req, res)
{
     writeHttpHeader(res)    
     fs.readdir('./videos-8081/frames', function(err, files)
     { 
         var i = -1;
         var sorted_files = files.sort();    
         setInterval(function()
         {
              if (++i >= sorted_files.length)
              {
                i = 0;
              }    
              writeJpegFrame(res, sorted_files[i]);
          }, framedelay);
        });
}).listen(port);
console.log('Server running at port ' + port);

Answer 1

当然它泄漏了记忆。你做了

 setInterval(...)

每个请求，但你永远不会清理这些间隔。这意味着在（例如）20个请求之后，你有20个时间间隔在后台运行，即使客户端/连接已经很长时间也会运行永远。其中一个解决方案如下：

var my_interval = setInterval(function() {
    try {
        // all your code goes here
    } catch(e) {
        // res.write should throw an exception once the connection is dead
        // do the cleaning now
        clearInterval( my_interval );
    }
}, frameDelay);

req.on( "close", function() {
    // just in case
    clearInterval( my_interval );
});

确保在连接关闭后清除my_interval（以及所有相应的数据）。

P.S。我建议使用setTimeout而不是setInterval，因为加载文件可能需要花费更多时间frameDelay，这会导致问题。

P.S.2。使用fs函数的异步版本。 Node.JS的整体功能处于非阻塞操作中，您在这里失去了主要优势（性能）。

Answer 2

有一些原因引起了这个

MJPEG不是设计用于以高频率发送高分辨率动态影像（25fps，在您的情况下，可能适用于320x240帧，但不适用于720p。）只考虑有效载荷的输出吞吐量25fps * 70KB = 1750KBps = 14Mbps，高于全高清视频。
当客户端无法接收时，Node.js会将输出缓存在缓冲区中。因为您要向客户端发送大量数据，所以节点会为您保存它们。这就是为什么你的内存使用量永远不会下降，而且 NOT 内存泄漏。要检测输出缓冲区是否已批量化，请检查res.write()。
setInterval()可以使用，只要客户端保持连接，就不会造成任何问题。但是当客户端断开连接时，您需要将其停止。为此，您需要监控“关闭”事件。
你不能通过使用MJPEG来保持稳定的fps，因为它不是为此而设计的，所以无论你怎么努力，你都无法控制客户端的fps。但是，通过精心设计的代码，您可以使用setTimeout()使平均fps 稳定。

这是固定代码。

var http = require('http');
var fs = require('fs');
var framedelay = 40;
var port = 3200;
var boundary = 'myboundary';
var CR = '\r';
var LF = '\n';
var CRLF = CR + LF;

http.createServer(function(req, res) {

  var files = fs.readdirSync('./imgs');
  var i = -1;
  var timer;
  var sorted_files = files.sort();

  res.writeHead(200, {
    'Content-Type': 'multipart/x-mixed-replace;boundary="' + boundary + '"',
    'Transfer-Encoding': 'none',
    'Connection': 'keep-alive',
    'Expires': 'Fri, 01 Jan 1990 00:00:00 GMT',
    'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate',
    'Pragma': 'no-cache',
  });

  res.write(CRLF + '--' + boundary + CRLF);

  var writePic = function() {

    if (++i >= sorted_files.length)
      i = 0;

    var data = fs.readFileSync('./imgs/' + sorted_files[i]);
    res.write('Content-Type:image/jpeg' + CRLF);
    res.write('Content-Length:' + data.length + CRLF + CRLF);
    res.write(data);
    var ok = res.write(CRLF + '--' + boundary + CRLF);
    console.log('Sent ' + sorted_files[i], ok);

    if (ok)
      timer = setTimeout(writePic, framedelay);
  };

  res.on('close', function() {
    console.log('client closed');
    clearTimeout(timer);
  });

  res.on('drain', function() {
    console.log('drain');
    timer = setTimeout(writePic, framedelay);
  });

}).listen(port);

console.log('Server running at port ' + port);

Node.js：内存使用率持续上升

2 个答案: