Node.js worker_threads多线程场景下console日志延迟集中输出问题

• Node.js 标准输出stdout默认启用缓冲策略：当输出目标不是交互终端（TTY）时会使用块缓冲，仅在缓冲区被填满、进程退出时才会统一输出内容。worker 线程的标准输出默认通过IPC通道转发给主线程，不属于TTY场景，因此会触发缓冲机制。
• 你实现的generatePrimes函数内的循环是纯CPU密集型同步代码，会独占worker线程的执行资源，完全阻塞事件循环调度，即使系统有缓冲区刷新的任务也无法执行，只能等到整个循环执行完成、线程退出前才会统一处理所有缓存的日志。

可选两种方案实现实时打印：

方案1：强制关闭标准输出缓冲 #

在worker线程执行逻辑的开头主动设置标准输出为无缓冲模式，写入内容会直接刷新输出，不需要修改循环逻辑：

'use strict';
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const min = 2;
const max = 1000000000; // 原代码未定义max变量，此处补充定义
let primes = [];
const mystring = 1  ;

function generatePrimes(mystr, range) {
   // worker线程内开启无缓冲输出
   if (!isMainThread) {
     process.stdout && process.stdout._handle && process.stdout._handle.setBlocking(true);
   }
   for (let i = 0; i < 1000000000; i++) {
       if (i===100000000){
         console.log(i);
       }
       if (i==200000000){
         console.log(i);
       }
       if (i==300000000){
         console.log(i);
       }
       mystr++
  }          
}

if (isMainThread) {
  const threadCount =2;
  const threads = new Set();
  console.log(`Running with ${threadCount} threads...`);
  const range = Math.ceil((max - min) / threadCount);
  let start = min;
  for (let i = 0; i < threadCount ; i++) {
    threads.add(new Worker(__filename, { workerData: { start: mystring, range }}));
    start += range;
  }
  for (let worker of threads) {
    worker.on('error', (err) => { throw err; });
    worker.on('exit', () => {
      threads.delete(worker);
      console.log(`Thread exiting, ${threads.size} running...`);
      if (threads.size === 0) {
        console.log(primes.join('\n'));
      }
    })
    worker.on('message', (msg) => {
      primes = primes.concat(msg);
    });
  }
} else {
  generatePrimes(workerData.start, workerData.range);
  parentPort.postMessage(primes);
}

方案2：在循环中插入微小间隙让出事件循环 #

如果不愿意修改输出缓冲配置，可以在打印后插入极短的异步调度，让出线程执行权给事件循环处理缓冲区刷新，性能损耗几乎可以忽略：

// 仅需要修改generatePrimes函数和worker调用逻辑即可
async function generatePrimes(mystr, range) {
   for (let i = 0; i < 1000000000; i++) {
       if (i===100000000 || i===200000000 || i===300000000){
         console.log(i);
         // 让出事件循环1次，处理输出刷新
         await new Promise(resolve => setImmediate(resolve));
       }
       mystr++
  }          
}

// 对应的worker线程调用处同步修改为异步等待：
// else {
//   generatePrimes(workerData.start, workerData.range).then(() => {
//     parentPort.postMessage(primes);
//   });
// }

内容的提问来源于stack exchange，提问作者Ramin Najafi