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