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[]> 1つ以上のMessagePortのようなオブジェクトがvalueで渡された場合、それらのアイテムにはtransferListが必要となり、そうでなければERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LISTがスローされます。詳細については、port.postMessage()を参照してください。
• timeout <number> メッセージが配信されるのを待つ時間(ミリ秒)。デフォルトはundefinedで、これは永久に待つことを意味します。操作がタイムアウトした場合、ERR_WORKER_MESSAGING_TIMEOUTエラーがスローされます。
• 戻り値: <Promise> メッセージが宛先スレッドによって正常に処理された場合に解決されるプロミス。

スレッドIDで識別される別のワーカーに値を送信します。

ターゲットスレッドにworkerMessageイベントのリスナーがない場合、操作はERR_WORKER_MESSAGING_FAILEDエラーをスローします。

ターゲットスレッドがworkerMessageイベントの処理中にエラーをスローした場合、操作はERR_WORKER_MESSAGING_ERROREDエラーをスローします。

このメソッドは、ターゲットスレッドが現在のスレッドの直接の親または子でない場合に使用する必要があります。2つのスレッドが親子関係にある場合は、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が返され、それ以外の場合はMessagePortのキュー内の最も古いメッセージに対応するメッセージペイロードを含む単一のmessageプロパティを持つオブジェクトが返されます。

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#

このスレッドのWorkerコンストラクタに渡されたデータのクローンを含む任意のJavaScript値。

データは、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インスタンスとの非同期の1対多通信を可能にします。

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()は、リンクされたMessagePortインスタンスを参照するport1とport2プロパティを持つオブジェクトを生成します。

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クラスのインスタンスは、非同期の双方向通信チャネルの一端を表します。構造化データ、メモリ領域、その他のMessagePortを異なるWorker間で転送するために使用できます。

この実装はブラウザの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がその中で利用可能です。

ワーカー環境内の注目すべき違いは

• process.stdin、process.stdout、およびprocess.stderrストリームは、親スレッドによってリダイレクトされる場合があります。
• require('node:worker_threads').isMainThreadプロパティはfalseに設定されます。
• require('node:worker_threads').parentPortメッセージポートが利用可能です。
• process.exit()はプログラム全体を停止せず、単一のスレッドのみを停止し、process.abort()は利用できません。
• process.chdir()およびグループIDまたはユーザーIDを設定するprocessメソッドは利用できません。
• process.envは、特に指定がない限り、親スレッドの環境変数のコピーです。一方のコピーへの変更は他のスレッドからは見えず、ネイティブアドオンからも見えません(worker.SHARE_ENVがWorkerコンストラクタのenvオプションとして渡されない限り)。Windowsでは、メインスレッドとは異なり、環境変数のコピーはケースセンシティブに動作します。
• process.titleは変更できません。
• シグナルはprocess.on('...')を介して配信されません。
• worker.terminate()が呼び出された結果として、実行はいつでも停止する可能性があります。
• 親プロセスからのIPCチャネルにはアクセスできません。
• trace_eventsモジュールはサポートされていません。
• ネイティブアドオンは、特定の条件を満たしている場合にのみ複数のスレッドからロードできます。

他のWorker内でWorkerインスタンスを作成することが可能です。

Web Workersやnode:clusterモジュールと同様に、スレッド間のメッセージパッシングを通じて双方向通信を実現できます。内部的に、Workerには、Workerが作成されたときにすでに関連付けられている組み込みのMessagePortのペアがあります。親側のMessagePortオブジェクトは直接公開されていませんが、その機能は親スレッドのWorkerオブジェクトのworker.postMessage()およびworker.on('message')イベントを通じて公開されています。

カスタムメッセージングチャネルを作成するには(関心の分離を促進するため、デフォルトのグローバルチャネルを使用するよりも推奨されます)、ユーザーはどちらかのスレッドでMessageChannelオブジェクトを作成し、そのMessageChannelのMessagePortの1つを、グローバルチャネルなどの既存のチャネルを通じて他のスレッドに渡すことができます。

メッセージがどのように渡され、どのような種類の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