Node.js v25.0.0 文档

worker_threads.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_threads.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_threads.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_threads.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 等效的功能。

worker_threads.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 等效的功能。

worker_threads.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 等效的功能。

worker_threads.moveMessagePortToContext(port, contextifiedSandbox)#

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

• contextifiedSandbox <Object> 一个由 vm.createContext() 方法返回的上下文隔离对象。

• 返回：<MessagePort>

将一个 MessagePort 传输到另一个 vm 上下文。原始的 port 对象变得不可用，返回的 MessagePort 实例将取而代之。

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

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

worker_threads.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_threads.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，如果消息被目标线程成功处理，则该 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_threads.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_threads.resourceLimits#

• 类型：<Object>
  • maxYoungGenerationSizeMb <number>
  • maxOldGenerationSizeMb <number>
  • codeRangeSizeMb <number>
  • stackSizeMb <number>

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

如果在主线程中使用此属性，其值为空对象。

worker_threads.SHARE_ENV#

• 类型：<symbol>

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

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_threads.setEnvironmentData(key[, value])#

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

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

worker_threads.threadId#

• 类型：<integer>

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

worker_threads.threadName#

• <string> | <null>

当前线程的字符串标识符，如果线程未运行则为 null。在相应的工作线程对象上（如果有），它作为 worker.threadName 可用。

worker_threads.workerData#

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

数据是根据 HTML 结构化克隆算法，如同使用 postMessage() 一样被克隆的。

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

worker_threads.locks#

• <LockManager>

一个 LockManager 实例，可用于协调对同一进程内多个线程可能共享的资源的访问。该 API 模仿了 浏览器 LockManager 的语义。

import { locks } from 'node:worker_threads';'use strict';

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

import { locks } from 'node:worker_threads';

await locks.request('my_resource', async (lock) => {
  // The lock has been acquired.
});
// The lock has been released here.'use strict';

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

locks.request('my_resource', async (lock) => {
  // The lock has been acquired.
}).then(() => {
  // The lock has been released here.
});copy

import { locks } from 'node:worker_threads';

const snapshot = await locks.query();
for (const lock of snapshot.held) {
  console.log(`held lock: name ${lock.name}, mode ${lock.mode}`);
}
for (const pending of snapshot.pending) {
  console.log(`pending lock: name ${pending.name}, mode ${pending.mode}`);
}'use strict';

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

locks.query().then((snapshot) => {
  for (const lock of snapshot.held) {
    console.log(`held lock: name ${lock.name}, mode ${lock.mode}`);
  }
  for (const pending of snapshot.pending) {
    console.log(`pending lock: name ${pending.name}, mode ${pending.mode}`);
  }
});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

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

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.on('message', () => {});
  `, { eval: true });

worker.on('online', async () => {
  const handle = await worker.startCpuProfile();
  const profile = await handle.stop();
  console.log(profile);
  worker.terminate();
}); copy

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

const w = new Worker(`
  const { parentPort } = require('node:worker_threads');
  parentPort.on('message', () => {});
  `, { eval: true });

w.on('online', async () => {
  // Stop profile automatically when return and profile will be discarded
  await using handle = await w.startCpuProfile();
}); copy

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

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.on('message', () => {});
  `, { eval: true });

worker.on('online', async () => {
  const handle = await worker.startHeapProfile();
  const profile = await handle.stop();
  console.log(profile);
  worker.terminate();
}); copy

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

const w = new Worker(`
  const { parentPort } = require('node:worker_threads');
  parentPort.on('message', () => {});
  `, { eval: true });

w.on('online', async () => {
  // Stop profile automatically when return and profile will be discarded
  await using handle = await w.startHeapProfile();
}); copy

async function example() {
  await using worker = new Worker('for (;;) {}', { eval: true });
  // Worker is automatically terminate when the scope is exited.
} 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