likely best for long-running application) or upon process exit (which is likely

most convenient for scripts).

* `value` {any} A value transmitted using [`postMessageToThread()`][].

* `source` {number} The transmitting worker thread ID or `0` for the main thread.

The `'workerMessage'` event is emitted for any incoming message send by the other

party by using [`postMessageToThread()`][].

[`net.Server`]: net.md#class-netserver

[`net.Socket`]: net.md#class-netsocket

[`os.constants.dlopen`]: os.md#dlopen-constants

[`postMessageToThread()`]: worker_threads.md#workerpostmessagetothreadthreadid-value-transferlist-timeout

[`process.argv`]: #processargv

[`process.config`]: #processconfig

[`process.execPath`]: #processexecpath

}

* `destination` {number} The target thread ID. If the thread ID is invalid, a

[`ERR_WORKER_MESSAGING_FAILED`][] error will be thrown. If the target thread ID is the current thread ID,

a [`ERR_WORKER_MESSAGING_SAME_THREAD`][] error will be thrown.

* `value` {any} The value to send.

* `transferList` {Object\[]} If one or more `MessagePort`-like objects are passed in `value`,

a `transferList` is required for those items or [`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`][] is thrown.

See [`port.postMessage()`][] for more information.

* `timeout` {number} Time to wait for the message to be delivered in milliseconds.

By default it's `undefined`, which means wait forever. If the operation times out,

a [`ERR_WORKER_MESSAGING_TIMEOUT`][] error is thrown.

* Returns: {Promise} A promise which is fulfilled if the message was successfully processed by destination thread.

Sends a value to another worker, identified by its thread ID.

If the target thread has no listener for the `workerMessage` event, then the operation will throw

a [`ERR_WORKER_MESSAGING_FAILED`][] error.

If the target thread threw an error while processing the `workerMessage` event, then the operation will throw

a [`ERR_WORKER_MESSAGING_ERRORED`][] error.

This method should be used when the target thread is not the direct

parent or child of the current thread.

If the two threads are parent-children, use the [`require('node:worker_threads').parentPort.postMessage()`][]

and the [`worker.postMessage()`][] to let the threads communicate.

The example below shows the use of of `postMessageToThread`: it creates 10 nested threads,

the last one will try to communicate with the main thread.

import { fileURLToPath } from 'node:url';

import { once } from 'node:events';

import process from 'node:process';

import {

isMainThread,

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(fileURLToPath(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;

```cjs

const { once } = require('node:events');

const {

isMainThread,

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;

## `worker.receiveMessageOnPort(port)`

[`Buffer.allocUnsafe()`]: buffer.md#static-method-bufferallocunsafesize

[`Buffer`]: buffer.md

[`ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST`]: errors.md#err_missing_message_port_in_transfer_list

[`ERR_WORKER_MESSAGING_ERRORED`]: errors.md#err_worker_messaging_errored

[`ERR_WORKER_MESSAGING_FAILED`]: errors.md#err_worker_messaging_failed

[`ERR_WORKER_MESSAGING_SAME_THREAD`]: errors.md#err_worker_messaging_same_thread

[`ERR_WORKER_MESSAGING_TIMEOUT`]: errors.md#err_worker_messaging_timeout

[`ERR_WORKER_NOT_RUNNING`]: errors.md#err_worker_not_running

[`EventTarget`]: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget

[`FileHandle`]: fs.md#class-filehandle

E('ERR_WORKER_INVALID_EXEC_ARGV', (errors, msg = 'invalid execArgv flags') =>

`Initiated Worker with ${msg}: ${ArrayPrototypeJoin(errors, ', ')}`,

Error);

E('ERR_WORKER_MESSAGING_ERRORED', 'The destination thread threw an error while processing the message', Error);

E('ERR_WORKER_MESSAGING_FAILED', 'Cannot find the destination thread or listener', Error);

E('ERR_WORKER_MESSAGING_SAME_THREAD', 'Cannot sent a message to the same thread', Error);

E('ERR_WORKER_MESSAGING_TIMEOUT', 'Sending a message to another thread timed out', Error);

E('ERR_WORKER_NOT_RUNNING', 'Worker instance not running', Error);

'Worker terminated due to reaching memory limit: %s', Error);

kStdioWantsMoreDataCallback,

} = workerIo;

const { setupMainThreadPort } = require('internal/worker/messaging');

const {

onGlobalUncaughtException,

} = require('internal/process/execution');

manifestURL,

publicPort,

workerData,

mainThreadPort,

} = message;

if (doEval !== 'internal') {

}

require('internal/worker').assignEnvironmentData(environmentData);

setupMainThreadPort(mainThreadPort);

if (SharedArrayBuffer !== undefined && Atomics !== undefined) {

// The counter is only passed to the workers created by the main thread,

ReadableWorkerStdio,

WritableWorkerStdio,

} = workerIo;

const { createMainThreadPort, destroyMainThreadPort } = require('internal/worker/messaging');

const { deserializeError } = require('internal/error_serdes');

const { fileURLToPath, isURL, pathToFileURL } = require('internal/url');

const { kEmptyObject } = require('internal/util');

this[kParentSideStdio] = { stdin, stdout, stderr };

const mainThreadPortToWorker = createMainThreadPort(this.threadId);

const {

port1: publicPortToParent,

port2: publicPortToWorker,

} = new MessageChannel();

const transferList = [mainThreadPortToWorker, publicPortToWorker];

// If transferList is provided.

if (options.transferList)

ArrayPrototypePush(transferList,

...new SafeArrayIterator(options.transferList));

this[kPublicPort] = publicPortToParent;

ArrayPrototypeForEach(['message', 'messageerror'], (event) => {

this[kPublicPort].on(event, (message) => this.emit(event, message));

});

cwdCounter: cwdCounter || workerIo.sharedCwdCounter,

workerData: options.workerData,

environmentData,

manifestURL: getOptionValue('--experimental-policy') ?

require('internal/process/policy').url :

null,

manifestSrc: getOptionValue('--experimental-policy') ?

require('internal/process/policy').src :

null,

hasStdin: !!options.stdin,

publicPort: publicPortToWorker,

mainThreadPort: mainThreadPortToWorker,

}, transferList);

// Use this to cache the Worker's loopStart value once available.

this[kLoopStartTime] = -1;

debug(`[${threadId}] hears end event for Worker ${this.threadId}`);

drainMessagePort(this[kPublicPort]);

drainMessagePort(this[kPort]);

destroyMainThreadPort(this.threadId);

this.removeAllListeners('message');

this.removeAllListeners('messageerrors');

this[kPublicPort].unref();