Node.js v24.0.0 文档

worker.getEnvironmentData(key)#

• key <any> 可以用作 <Map> 键的任何任意的、可克隆的 JavaScript 值。
• 返回: <any>

在工作线程中，worker.getEnvironmentData() 返回传递给生成线程的 worker.setEnvironmentData() 的数据的克隆。 每个新的 Worker 自动接收其自己的环境数据副本。

import {
  Worker,
  isMainThread,
  setEnvironmentData,
  getEnvironmentData,
} from 'node:worker_threads';

if (isMainThread) {
  setEnvironmentData('Hello', 'World!');
  const worker = new Worker(new URL(import.meta.url));
} else {
  console.log(getEnvironmentData('Hello'));  // Prints 'World!'.
}'use strict';

const {
  Worker,
  isMainThread,
  setEnvironmentData,
  getEnvironmentData,
} = require('node:worker_threads');

if (isMainThread) {
  setEnvironmentData('Hello', 'World!');
  const worker = new Worker(__filename);
} else {
  console.log(getEnvironmentData('Hello'));  // Prints 'World!'.
}copy

worker.isInternalThread#

• <boolean>

如果此代码在内部 Worker 线程（例如加载器线程）中运行，则为 true。

node --experimental-loader ./loader.js main.js copy

// loader.js
import { isInternalThread } from 'node:worker_threads';
console.log(isInternalThread);  // true// loader.js
'use strict';

const { isInternalThread } = require('node:worker_threads');
console.log(isInternalThread);  // truecopy

// main.js
import { isInternalThread } from 'node:worker_threads';
console.log(isInternalThread);  // false// main.js
'use strict';

const { isInternalThread } = require('node:worker_threads');
console.log(isInternalThread);  // falsecopy

worker.isMainThread#

• <boolean>

如果此代码未在 Worker 线程中运行，则为 true。

import { Worker, isMainThread } from 'node:worker_threads';

if (isMainThread) {
  // This re-loads the current file inside a Worker instance.
  new Worker(new URL(import.meta.url));
} else {
  console.log('Inside Worker!');
  console.log(isMainThread);  // Prints 'false'.
}'use strict';

const { Worker, isMainThread } = require('node:worker_threads');

if (isMainThread) {
  // This re-loads the current file inside a Worker instance.
  new Worker(__filename);
} else {
  console.log('Inside Worker!');
  console.log(isMainThread);  // Prints 'false'.
}copy

worker.markAsUntransferable(object)#

• object <any> 任何任意的 JavaScript 值。

将对象标记为不可传输。 如果 object 出现在 port.postMessage() 调用的传输列表中，则会抛出错误。 如果 object 是原始值，则此操作无效。

特别是，这对于可以克隆而不是传输的对象，以及发送方其他对象使用的对象来说是有意义的。 例如，Node.js 使用此方法标记它用于其 Buffer 池的 ArrayBuffer。

此操作无法撤消。

import { MessageChannel, markAsUntransferable } from 'node:worker_threads';

const pooledBuffer = new ArrayBuffer(8);
const typedArray1 = new Uint8Array(pooledBuffer);
const typedArray2 = new Float64Array(pooledBuffer);

markAsUntransferable(pooledBuffer);

const { port1 } = new MessageChannel();
try {
  // This will throw an error, because pooledBuffer is not transferable.
  port1.postMessage(typedArray1, [ typedArray1.buffer ]);
} catch (error) {
  // error.name === 'DataCloneError'
}

// The following line prints the contents of typedArray1 -- it still owns
// its memory and has not been transferred. Without
// `markAsUntransferable()`, this would print an empty Uint8Array and the
// postMessage call would have succeeded.
// typedArray2 is intact as well.
console.log(typedArray1);
console.log(typedArray2);'use strict';

const { MessageChannel, markAsUntransferable } = require('node:worker_threads');

const pooledBuffer = new ArrayBuffer(8);
const typedArray1 = new Uint8Array(pooledBuffer);
const typedArray2 = new Float64Array(pooledBuffer);

markAsUntransferable(pooledBuffer);

const { port1 } = new MessageChannel();
try {
  // This will throw an error, because pooledBuffer is not transferable.
  port1.postMessage(typedArray1, [ typedArray1.buffer ]);
} catch (error) {
  // error.name === 'DataCloneError'
}

// The following line prints the contents of typedArray1 -- it still owns
// its memory and has not been transferred. Without
// `markAsUntransferable()`, this would print an empty Uint8Array and the
// postMessage call would have succeeded.
// typedArray2 is intact as well.
console.log(typedArray1);
console.log(typedArray2);copy

浏览器中没有与此 API 等效的 API。

worker.isMarkedAsUntransferable(object)#

• object <any> 任何 JavaScript 值。
• 返回: <boolean>

检查对象是否使用 markAsUntransferable() 标记为不可传输。

import { markAsUntransferable, isMarkedAsUntransferable } from 'node:worker_threads';

const pooledBuffer = new ArrayBuffer(8);
markAsUntransferable(pooledBuffer);

isMarkedAsUntransferable(pooledBuffer);  // Returns true.'use strict';

const { markAsUntransferable, isMarkedAsUntransferable } = require('node:worker_threads');

const pooledBuffer = new ArrayBuffer(8);
markAsUntransferable(pooledBuffer);

isMarkedAsUntransferable(pooledBuffer);  // Returns true.copy

浏览器中没有与此 API 等效的 API。

worker.markAsUncloneable(object)#

• object <any> 任何任意的 JavaScript 值。

将对象标记为不可克隆。 如果 object 在 port.postMessage() 调用中用作 message，则会抛出错误。 如果 object 是原始值，则此操作无效。

这对 ArrayBuffer 或任何类似 Buffer 的对象没有影响。

此操作无法撤消。

import { markAsUncloneable } from 'node:worker_threads';

const anyObject = { foo: 'bar' };
markAsUncloneable(anyObject);
const { port1 } = new MessageChannel();
try {
  // This will throw an error, because anyObject is not cloneable.
  port1.postMessage(anyObject);
} catch (error) {
  // error.name === 'DataCloneError'
}'use strict';

const { markAsUncloneable } = require('node:worker_threads');

const anyObject = { foo: 'bar' };
markAsUncloneable(anyObject);
const { port1 } = new MessageChannel();
try {
  // This will throw an error, because anyObject is not cloneable.
  port1.postMessage(anyObject);
} catch (error) {
  // error.name === 'DataCloneError'
}copy

浏览器中没有与此 API 等效的 API。

worker.moveMessagePortToContext(port, contextifiedSandbox)#

• port <MessagePort> 要传输的消息端口。

• contextifiedSandbox <Object> 由 vm.createContext() 方法返回的 contextified 对象。

• 返回: <MessagePort>

将 MessagePort 传输到不同的 vm 上下文。 原始的 port 对象变为不可用，并且返回的 MessagePort 实例取代它。

返回的 MessagePort 是目标上下文中的一个对象，并继承自它的全局 Object 类。 传递给 port.onmessage() 监听器的对象也在目标上下文中创建，并继承自它的全局 Object 类。

但是，创建的 MessagePort 不再继承自 <EventTarget>，并且只能使用 port.onmessage() 来接收事件。

worker.parentPort#

• <null> | <MessagePort>

如果此线程是 Worker，则这是一个 MessagePort，允许与父线程进行通信。 使用 parentPort.postMessage() 发送的消息在使用 worker.on('message') 的父线程中可用，并且从父线程使用 worker.postMessage() 发送的消息在使用 parentPort.on('message') 的此线程中可用。

import { Worker, isMainThread, parentPort } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url));
  worker.once('message', (message) => {
    console.log(message);  // Prints 'Hello, world!'.
  });
  worker.postMessage('Hello, world!');
} else {
  // When a message from the parent thread is received, send it back:
  parentPort.once('message', (message) => {
    parentPort.postMessage(message);
  });
}'use strict';

const { Worker, isMainThread, parentPort } = require('node:worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.once('message', (message) => {
    console.log(message);  // Prints 'Hello, world!'.
  });
  worker.postMessage('Hello, world!');
} else {
  // When a message from the parent thread is received, send it back:
  parentPort.once('message', (message) => {
    parentPort.postMessage(message);
  });
}copy

worker.postMessageToThread(threadId, value[, transferList][, timeout])#

• threadId <number> 目标线程 ID。 如果线程 ID 无效，则会抛出 ERR_WORKER_MESSAGING_FAILED 错误。 如果目标线程 ID 是当前线程 ID，则会抛出 ERR_WORKER_MESSAGING_SAME_THREAD 错误。
• value <any> 要发送的值。
• transferList <Object[]> 如果在 value 中传递了一个或多个类似于 MessagePort 的对象，则必须为这些项提供 transferList，否则会抛出 ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST 错误。 有关更多信息，请参见 port.postMessage()。
• timeout <number> 等待消息传递的最长时间，以毫秒为单位。 默认值为 undefined，表示永远等待。 如果操作超时，则会抛出 ERR_WORKER_MESSAGING_TIMEOUT 错误。
• 返回: <Promise> 如果消息已由目标线程成功处理，则 promise 将被兑现。

向另一个工作线程发送一个值，该工作线程由其线程 ID 标识。

如果目标线程没有 workerMessage 事件的监听器，则该操作将抛出 ERR_WORKER_MESSAGING_FAILED 错误。

如果目标线程在处理 workerMessage 事件时抛出一个错误，则该操作将抛出一个 ERR_WORKER_MESSAGING_ERRORED 错误。

当目标线程不是当前线程的直接父级或子级时，应使用此方法。 如果两个线程是父子关系，请使用 require('node:worker_threads').parentPort.postMessage() 和 worker.postMessage() 以便线程进行通信。

下面的示例展示了 postMessageToThread 的用法：它创建了 10 个嵌套的线程，最后一个线程将尝试与主线程通信。

import process from 'node:process';
import {
  postMessageToThread,
  threadId,
  workerData,
  Worker,
} from 'node:worker_threads';

const channel = new BroadcastChannel('sync');
const level = workerData?.level ?? 0;

if (level < 10) {
  const worker = new Worker(new URL(import.meta.url), {
    workerData: { level: level + 1 },
  });
}

if (level === 0) {
  process.on('workerMessage', (value, source) => {
    console.log(`${source} -> ${threadId}:`, value);
    postMessageToThread(source, { message: 'pong' });
  });
} else if (level === 10) {
  process.on('workerMessage', (value, source) => {
    console.log(`${source} -> ${threadId}:`, value);
    channel.postMessage('done');
    channel.close();
  });

  await postMessageToThread(0, { message: 'ping' });
}

channel.onmessage = channel.close;'use strict';

const process = require('node:process');
const {
  postMessageToThread,
  threadId,
  workerData,
  Worker,
} = require('node:worker_threads');

const channel = new BroadcastChannel('sync');
const level = workerData?.level ?? 0;

if (level < 10) {
  const worker = new Worker(__filename, {
    workerData: { level: level + 1 },
  });
}

if (level === 0) {
  process.on('workerMessage', (value, source) => {
    console.log(`${source} -> ${threadId}:`, value);
    postMessageToThread(source, { message: 'pong' });
  });
} else if (level === 10) {
  process.on('workerMessage', (value, source) => {
    console.log(`${source} -> ${threadId}:`, value);
    channel.postMessage('done');
    channel.close();
  });

  postMessageToThread(0, { message: 'ping' });
}

channel.onmessage = channel.close;copy

worker.receiveMessageOnPort(port)#

• port <MessagePort> | <BroadcastChannel>

• 返回: <Object> | <undefined>

从给定的 MessagePort 接收单个消息。 如果没有可用的消息，则返回 undefined，否则返回一个具有单个 message 属性的对象，该属性包含消息有效负载，对应于 MessagePort 队列中最旧的消息。

import { MessageChannel, receiveMessageOnPort } from 'node:worker_threads';
const { port1, port2 } = new MessageChannel();
port1.postMessage({ hello: 'world' });

console.log(receiveMessageOnPort(port2));
// Prints: { message: { hello: 'world' } }
console.log(receiveMessageOnPort(port2));
// Prints: undefined'use strict';

const { MessageChannel, receiveMessageOnPort } = require('node:worker_threads');
const { port1, port2 } = new MessageChannel();
port1.postMessage({ hello: 'world' });

console.log(receiveMessageOnPort(port2));
// Prints: { message: { hello: 'world' } }
console.log(receiveMessageOnPort(port2));
// Prints: undefinedcopy

使用此函数时，不会发出 'message' 事件，也不会调用 onmessage 监听器。

worker.resourceLimits#

• <Object>
  • maxYoungGenerationSizeMb <number>
  • maxOldGenerationSizeMb <number>
  • codeRangeSizeMb <number>
  • stackSizeMb <number>

提供此 Worker 线程内的 JS 引擎资源约束集。 如果将 resourceLimits 选项传递给 Worker 构造函数，则此值与其值匹配。

如果在主线程中使用此方法，则其值为空对象。

worker.SHARE_ENV#

• <symbol>

一个特殊的值，可以作为 Worker 构造函数的 env 选项传递，以指示当前线程和 Worker 线程应共享对同一组环境变量的读写访问权限。

import process from 'node:process';
import { Worker, SHARE_ENV } from 'node:worker_threads';
new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV })
  .on('exit', () => {
    console.log(process.env.SET_IN_WORKER);  // Prints 'foo'.
  });'use strict';

const { Worker, SHARE_ENV } = require('node:worker_threads');
new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV })
  .on('exit', () => {
    console.log(process.env.SET_IN_WORKER);  // Prints 'foo'.
  });copy

worker.setEnvironmentData(key[, value])#

• key <any> 可以用作 <Map> 键的任何任意的、可克隆的 JavaScript 值。
• value <any> 任何任意的、可克隆的 JavaScript 值，这些值将被克隆并自动传递给所有新的 Worker 实例。 如果将 value 作为 undefined 传递，则将删除先前为 key 设置的任何值。

worker.setEnvironmentData() API 设置当前线程和从当前上下文生成的所有新 Worker 实例中 worker.getEnvironmentData() 的内容。

worker.threadId#

• <integer>

当前线程的整数标识符。 在相应的工作线程对象上（如果有），它可用作 worker.threadId。 此值对于单个进程中的每个 Worker 实例都是唯一的。

worker.workerData#

一个任意的 JavaScript 值，其中包含传递给此线程的 Worker 构造函数的数据的克隆。

数据被克隆，就像使用 postMessage() 一样，根据 HTML 结构化克隆算法。

import { Worker, isMainThread, workerData } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url), { workerData: 'Hello, world!' });
} else {
  console.log(workerData);  // Prints 'Hello, world!'.
}'use strict';

const { Worker, isMainThread, workerData } = require('node:worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename, { workerData: 'Hello, world!' });
} else {
  console.log(workerData);  // Prints 'Hello, world!'.
}copy

类: BroadcastChannel extends EventTarget#

BroadcastChannel 的实例允许与绑定到同一通道名称的所有其他 BroadcastChannel 实例进行异步的一对多通信。

import {
  isMainThread,
  BroadcastChannel,
  Worker,
} from 'node:worker_threads';

const bc = new BroadcastChannel('hello');

if (isMainThread) {
  let c = 0;
  bc.onmessage = (event) => {
    console.log(event.data);
    if (++c === 10) bc.close();
  };
  for (let n = 0; n < 10; n++)
    new Worker(new URL(import.meta.url));
} else {
  bc.postMessage('hello from every worker');
  bc.close();
}'use strict';

const {
  isMainThread,
  BroadcastChannel,
  Worker,
} = require('node:worker_threads');

const bc = new BroadcastChannel('hello');

if (isMainThread) {
  let c = 0;
  bc.onmessage = (event) => {
    console.log(event.data);
    if (++c === 10) bc.close();
  };
  for (let n = 0; n < 10; n++)
    new Worker(__filename);
} else {
  bc.postMessage('hello from every worker');
  bc.close();
}copy

类: MessageChannel#

worker.MessageChannel 类的实例表示一个异步的双向通信通道。 MessageChannel 没有自己的方法。 new MessageChannel() 产生一个具有 port1 和 port2 属性的对象，这些属性引用链接的 MessagePort 实例。

import { MessageChannel } from 'node:worker_threads';

const { port1, port2 } = new MessageChannel();
port1.on('message', (message) => console.log('received', message));
port2.postMessage({ foo: 'bar' });
// Prints: received { foo: 'bar' } from the `port1.on('message')` listener'use strict';

const { MessageChannel } = require('node:worker_threads');

const { port1, port2 } = new MessageChannel();
port1.on('message', (message) => console.log('received', message));
port2.postMessage({ foo: 'bar' });
// Prints: received { foo: 'bar' } from the `port1.on('message')` listenercopy

类: MessagePort#

• 继承自: <EventTarget>

worker.MessagePort 类的实例表示异步双向通信通道的一端。 它可用于在不同的 Worker 之间传输结构化数据、内存区域和其他 MessagePort。

此实现与 浏览器 MessagePort 匹配。

import { MessageChannel } from 'node:worker_threads';
const { port1, port2 } = new MessageChannel();

// Prints:
//   foobar
//   closed!
port2.on('message', (message) => console.log(message));
port2.on('close', () => console.log('closed!'));

port1.postMessage('foobar');
port1.close();'use strict';

const { MessageChannel } = require('node:worker_threads');
const { port1, port2 } = new MessageChannel();

// Prints:
//   foobar
//   closed!
port2.on('message', (message) => console.log(message));
port2.on('close', () => console.log('closed!'));

port1.postMessage('foobar');
port1.close();copy

import { MessageChannel } from 'node:worker_threads';
const { port1, port2 } = new MessageChannel();

port1.on('message', (message) => console.log(message));

const circularData = {};
circularData.foo = circularData;
// Prints: { foo: [Circular] }
port2.postMessage(circularData);'use strict';

const { MessageChannel } = require('node:worker_threads');
const { port1, port2 } = new MessageChannel();

port1.on('message', (message) => console.log(message));

const circularData = {};
circularData.foo = circularData;
// Prints: { foo: [Circular] }
port2.postMessage(circularData);copy

import { MessageChannel } from 'node:worker_threads';
const { port1, port2 } = new MessageChannel();

port1.on('message', (message) => console.log(message));

const uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);
// This posts a copy of `uint8Array`:
port2.postMessage(uint8Array);
// This does not copy data, but renders `uint8Array` unusable:
port2.postMessage(uint8Array, [ uint8Array.buffer ]);

// The memory for the `sharedUint8Array` is accessible from both the
// original and the copy received by `.on('message')`:
const sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));
port2.postMessage(sharedUint8Array);

// This transfers a freshly created message port to the receiver.
// This can be used, for example, to create communication channels between
// multiple `Worker` threads that are children of the same parent thread.
const otherChannel = new MessageChannel();
port2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);'use strict';

const { MessageChannel } = require('node:worker_threads');
const { port1, port2 } = new MessageChannel();

port1.on('message', (message) => console.log(message));

const uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);
// This posts a copy of `uint8Array`:
port2.postMessage(uint8Array);
// This does not copy data, but renders `uint8Array` unusable:
port2.postMessage(uint8Array, [ uint8Array.buffer ]);

// The memory for the `sharedUint8Array` is accessible from both the
// original and the copy received by `.on('message')`:
const sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));
port2.postMessage(sharedUint8Array);

// This transfers a freshly created message port to the receiver.
// This can be used, for example, to create communication channels between
// multiple `Worker` threads that are children of the same parent thread.
const otherChannel = new MessageChannel();
port2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);copy

const ab = new ArrayBuffer(10);

const u1 = new Uint8Array(ab);
const u2 = new Uint16Array(ab);

console.log(u2.length);  // prints 5

port.postMessage(u1, [u1.buffer]);

console.log(u2.length);  // prints 0 copy

const b = Symbol('b');

class Foo {
  #a = 1;
  constructor() {
    this[b] = 2;
    this.c = 3;
  }

  get d() { return 4; }
}

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => console.log(data);

port2.postMessage(new Foo());

// Prints: { c: 3 } copy

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => console.log(data);

port2.postMessage(new URL('https://example.org'));

// Prints: { } copy

类: Worker#

• 继承自: <EventEmitter>

Worker 类表示一个独立的 JavaScript 执行线程。 大多数 Node.js API 都可以在其中使用。

Worker 环境内部的显着差异是

• process.stdin、process.stdout 和 process.stderr 流可以被父线程重定向。
• require('node:worker_threads').isMainThread 属性设置为 false。
• require('node:worker_threads').parentPort 消息端口可用。
• process.exit() 不会停止整个程序，而只会停止单个线程，并且 process.abort() 不可用。
• process.chdir() 和设置组或用户 ID 的 process 方法不可用。
• process.env 是父线程的环境变量的副本，除非另有说明。 对一个副本的更改在其他线程中不可见，并且对本机插件不可见（除非将 worker.SHARE_ENV 作为 env 选项传递给 Worker 构造函数）。 在 Windows 上，与主线程不同，环境变量的副本以区分大小写的方式运行。
• process.title 无法修改。
• 信号不会通过 process.on('...') 传递。
• 由于调用了 worker.terminate()，因此执行可能随时停止。
• 无法访问来自父进程的 IPC 通道。
• 不支持 trace_events 模块。
• 仅当本机插件满足某些条件时，才能从多个线程加载本机插件。

在其他 Worker 内部创建 Worker 实例是可能的。

与 Web Workers 和 node:cluster 模块类似，可以通过线程间消息传递来实现双向通信。 在内部，Worker 有一对内置的 MessagePort，它们在创建 Worker 时已彼此关联。 虽然父端上的 MessagePort 对象未直接公开，但其功能通过 worker.postMessage() 和 父线程上 Worker 对象上的 worker.on('message') 事件公开。

要创建自定义消息传递通道（建议不要使用默认的全局通道，因为它有助于分离关注点），用户可以在任一线程上创建一个 MessageChannel 对象，并通过一个预先存在的通道（例如全局通道）将该 MessageChannel 上的 MessagePort 之一传递给另一个线程。

有关消息如何传递以及哪种 JavaScript 值可以成功通过线程屏障传输的更多信息，请参阅port.postMessage()。

import assert from 'node:assert';
import {
  Worker, MessageChannel, MessagePort, isMainThread, parentPort,
} from 'node:worker_threads';
if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url));
  const subChannel = new MessageChannel();
  worker.postMessage({ hereIsYourPort: subChannel.port1 }, [subChannel.port1]);
  subChannel.port2.on('message', (value) => {
    console.log('received:', value);
  });
} else {
  parentPort.once('message', (value) => {
    assert(value.hereIsYourPort instanceof MessagePort);
    value.hereIsYourPort.postMessage('the worker is sending this');
    value.hereIsYourPort.close();
  });
}'use strict';

const assert = require('node:assert');
const {
  Worker, MessageChannel, MessagePort, isMainThread, parentPort,
} = require('node:worker_threads');
if (isMainThread) {
  const worker = new Worker(__filename);
  const subChannel = new MessageChannel();
  worker.postMessage({ hereIsYourPort: subChannel.port1 }, [subChannel.port1]);
  subChannel.port2.on('message', (value) => {
    console.log('received:', value);
  });
} else {
  parentPort.once('message', (value) => {
    assert(value.hereIsYourPort instanceof MessagePort);
    value.hereIsYourPort.postMessage('the worker is sending this');
    value.hereIsYourPort.close();
  });
}copy

import { Worker, isMainThread, parentPort } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url));
  setInterval(() => {
    worker.postMessage('hi');
    console.log(worker.performance.eventLoopUtilization());
  }, 100).unref();
} else {
  parentPort.on('message', () => console.log('msg')).unref();
  (function r(n) {
    if (--n < 0) return;
    const t = Date.now();
    while (Date.now() - t < 300);
    setImmediate(r, n);
  })(10);
}'use strict';

const { Worker, isMainThread, parentPort } = require('node:worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  setInterval(() => {
    worker.postMessage('hi');
    console.log(worker.performance.eventLoopUtilization());
  }, 100).unref();
} else {
  parentPort.on('message', () => console.log('msg')).unref();
  (function r(n) {
    if (--n < 0) return;
    const t = Date.now();
    while (Date.now() - t < 300);
    setImmediate(r, n);
  })(10);
}copy

说明#

import {
  Worker,
  isMainThread,
} from 'node:worker_threads';

if (isMainThread) {
  new Worker(new URL(import.meta.url));
  for (let n = 0; n < 1e10; n++) {
    // Looping to simulate work.
  }
} else {
  // This output will be blocked by the for loop in the main thread.
  console.log('foo');
}'use strict';

const {
  Worker,
  isMainThread,
} = require('node:worker_threads');

if (isMainThread) {
  new Worker(__filename);
  for (let n = 0; n < 1e10; n++) {
    // Looping to simulate work.
  }
} else {
  // This output will be blocked by the for loop in the main thread.
  console.log('foo');
}copy