如何使用 node.js 在 stdout 中编写阻塞？

Question

我正在编写一个 node.js 应用程序，其中 stdout 通过管道传输到文件。我正在用 console.log 编写所有内容。一段时间后，我的应用程序达到 1GB 限制并停止。有趣的是，如果我使用 console.error 而不是 console.log，内存使用率保持较低并且程序运行良好。所以看起来 Node.js 无法刷新标准输出流，所有内容都保存在内存中。我想让 stderr 不出现错误。

我的问题是：

有没有办法将阻塞写入标准输出？或者至少，我可以使用对标准输出的回调进行写入，这样我就可以确保我不会写太多？

谢谢！

Answer 1

如果你真的想要同步写入标准输出，你可以这样做：

var fs = require('fs');
fs.writeSync(1, "Foo\n");
fs.fsyncSync(1);

Answer 2

使用 process.stdout.write 编写，返回值是数据是否被缓冲。如果为 true，则在 process.stdout 发出 drain 事件时继续写入。

如果您希望代码看起来同步，请按照此处所述使用streamlinejs： Node.js stdoutlush

Answer 3

出现该问题（内存使用量爆炸）的原因可能是您的程序创建输出的速度比显示输出的速度快。因此你想限制它。您的问题要求“同步输出”，但实际上可以通过使用纯粹的“异步”(*) 代码来解决问题。

（*注意：在这篇文章中，术语“异步”用于“javascript-单线程”的含义。这与传统的“多线程”含义不同，后者完全不同）

这个答案展示了如何将“异步”代码与 Promise 结合使用，通过“暂停”（而不是阻塞）执行直到成功刷新写入输出来防止内存使用量激增。该答案还解释了异步代码解决方案与同步代码解决方案相比有何优势。

问：“暂停”听起来像“阻塞”，异步代码怎么可能“阻塞”？这是一个矛盾的说法！

答：它之所以有效，是因为 javascript v8 引擎仅暂停（阻止）执行等待异步承诺完成的单个代码片，同时允许其他代码片执行同时。

这是一个异步写入函数（改编自 此处）。

async function streamWriteAsync(
  stream,
  chunk,
  encoding='utf8') {
  return await new Promise((resolve, reject) => {
    const errListener = (err) => {
      stream.removeListener('error', errListener);
      reject(err);
    };
    stream.addListener('error', errListener);
    const callback = () => {
      stream.removeListener('error', errListener);
      resolve(undefined);
    };
    stream.write(chunk, encoding, callback);
  });
}

可以从源代码中的异步函数调用它，例如
情况 1

async function main() {
  while (true)
    await streamWriteAsync(process.stdout, 'hello world\n')
}
main();

其中 main() 是从顶层调用的唯一函数。内存使用量不会像调用console.log('hello world');那样激增。

需要更多上下文才能清楚地看到相对于真正的同步写入的优势：
情况 2

async function logger() {
  while (true)
    await streamWriteAsync(process.stdout, 'hello world\n')
}
const snooze = ms => new Promise(resolve => setTimeout(resolve, ms));
function allowOtherThreadsToRun(){
  return Promise(resolve => setTimeout(resolve, 0));
}
async function essentialWorker(){
  let a=0,b=1;
  while (true) {
    let tmp=a; a=b; b=tmp;
    allowOtherThreadsToRun();
  }
}
async function main(){
  Promise.all([logger(), essentialWorker()])  
}
main();

运行上面的代码（情况 2）会显示内存使用量仍然没有爆炸（与情况 1 相同），因为 < code>logger 关联的切片已暂停，但 CPU 使用率仍然如此，因为 essentialWorker 切片没有暂停 - 这很好（想想新冠肺炎）。

相比之下，同步解决方案也会阻塞 essentialWorker。

多个切片调用 streamWrite 会发生什么？
情况3

async function loggerHi() {
  while (true)
    await streamWriteAsync(process.stdout, 'hello world\n')
}
async function loggerBye() {
  while (true)
    await streamWriteAsync(process.stdout, 'goodbye world\n')
}
function allowOtherThreadsToRun(){
  return Promise(resolve => setTimeout(resolve, 0));
}
async function essentialWorker(){
  let a=0,b=1;
  while (true) {
    let tmp=a; a=b; b=tmp;
    allowOtherThreadsToRun();
  }
}
async function main(){
  Promise.all([loggerHi(), loggerBye(), essentialWorker()])  
}
main();

本情况（情况3），内存使用受限，essentialWorker CPU使用率较高，同<案例 2。 hello world 和 goodbye world 的各个行将保持原子性，但这些行不会干净地交替，例如，

...
hello world 
hello world 
goodbye world 
hello world 
hello world 
...

可能会出现。

Answer 4

编辑：正如评论者指出的，这个解决方案有问题。 printResolver 可以做成一个数组，但使用顶级解决方案要容易得多。

同步打印函数也可以使用异步/等待，与管道（又名 FIFO）一起使用。
确保您始终使用“等待打印”来调用“打印”

let printResolver;
process.stdout.on('drain', function () {
    if (printResolver) printResolver();
});

async function print(str) {
    var done = process.stdout.write(str);
    if (!done) {
        await new Promise(function (resolve) {
            printResolver = resolve;
        });
    }
}

Answer 5

不。

您想要做的是当输出已满时pause()您的输入，就像pump()方法一样，然后resume()当你有空间写的时候就可以了。如果没有，您的流程就会变得非常庞大。

不过，您可能想使用更直接的 outputStream 内容，或者 write() 调用，而不是 console.log()。