1

我有一个应用程序，它必须从视频中提取颜色信息，它通过分析每一帧来做到这一点。首先，我提取帧，然后将它们的位置数组加载到内存中。正如您可能想象的那样，即使是一个小视频也可能有数千个。

我用来提取每个帧颜色信息的函数是一个承诺，所以我选择批量处理一组承诺Promise.all

对于每个文件的绝对路径，我读取文件，fs然后将其传递以进行处理。我已经使用许多独立图像完成了此操作，并且知道该过程只需要大约一秒钟，但突然间处理一张图像需要将近 20 分钟。我终于发现使用promisifyonfs.readFile是造成瓶颈的原因。我不明白的是为什么？

在第一个fs.readFile中，在返回的 Promise 中进行了转换，而在第二个fs.readFile中，它只是像往常一样使用，我等待 resolve 被调用。我不介意使用无承诺的，我只是好奇为什么这会导致这么慢？

我停止使用promisify该应用程序的第二秒速度恢复到 1 帧/秒

慢代码：

   async analyzeVideo(){
    await this._saveVideo();
    await this._extractFrames();
    await this._removeVideo();

    const colorPromises = this.frameExtractor.frames.map(file => {
      return new Promise(resolve => {
        //transform image into data
        const readFile = promisify(fs.readFile);
        readFile(file)
            .then(data => {
              const analyzer = new ColorAnalyzer(data);
              analyzer.init()
                  .then(colors => {
                    resolve(colors)
                  })
            })
            .catch((e)=> console.log(e));
      })
    });
    const colors = await runAllQueries(colorPromises);

    await this._removeFrames();

    this.colors = colors;

    async function runAllQueries(promises) {
      const batches = _.chunk(promises, 50);
      const results = [];
      while (batches.length) {
        const batch = batches.shift();
        const result = await Promise.all(batch)
            .catch(e=>console.log(e));
        results.push(result)
      }
      return _.flatten(results);
    }
  }

快速代码：

async analyzeVideo(){
    await this._saveVideo();
    await this._extractFrames();
    await this._removeVideo();
    const colorPromises = this.frameExtractor.frames.map(file => {
      return new Promise(resolve => {
        //transform image into data
        fs.readFile(file, (err, data) => {
          const analyzer = new ColorAnalyzer(data);
          analyzer.init()
              .then(colors => {
                resolve(colors)
              })
        });
      })
    });
    const colors = await runAllQueries(colorPromises);

    await this._removeFrames();

    this.colors = colors;

    async function runAllQueries(promises) {
      const batches = _.chunk(promises, 50);
      const results = [];
      while (batches.length) {
        const batch = batches.shift();
        const result = await Promise.all(batch)
            .catch(e=>console.log(e));
        results.push(result)
      }
      return _.flatten(results);
    }
  }
4

1 回答 1

1

您不需要promisify在每个循环迭代中执行一次，只需在模块顶部执行一次。

这个问题很可能是由从未解决的 Promise 引起的。您没有正确处理错误，因此Promise.all如果抛出错误，可能永远不会完成。

除了将错误记录在 中.catch，您也必须这样做reject，或者resolve至少在您不关心错误的情况下。也analyzer.init()没有捕获错误（如果该函数可以拒绝）

const readFile = promisify(fs.readFile);
// ...

const colorPromises = this.frameExtractor.frames.map(file => {
   return new Promise((resolve, reject) => {
        //transform image into data
        // const readFile = promisify(fs.readFile);
        readFile(file)
            .then(data => {
              const analyzer = new ColorAnalyzer(data);
              return analyzer.init()   
            })
            .then(resolve) // colors
            .catch((e)=> { 
              reject(e);
              console.log(e)
            });
      })
})

除此之外，runAllQueries没有做你认为它正在做的事情。你已经执行了所有的承诺。

我建议您改用p -limit

const pLimit = require('p-limit');

const limit = pLimit(50);

/* ... */

const colorPromises = this.frameExtractor.frames.map(file => {
   return limit(() => {
        return readFile(file)
            .then(data => {
              const analyzer = new ColorAnalyzer(data);
              return analyzer.init()   
            })
            .then(resolve) // colors
    })
})

const colors = await Promise.all(colorPromises);

此外，如果您一次执行 50 次读取，则应将UV_THREADPOOL_SIZE其默认值增加到 4。

在您的入口点，在任何要求之前：

process.env.UV_THREADPOOL_SIZE = 64 // up to 128

或将脚本称为：UV_THREADPOOL_SIZE=64 node index.js

于 2019-12-10T19:51:57.010 回答