Worker threads

Worker threads

Stability: 2 - Stable

The node:worker_threads module enables the use of threads that execute JavaScript in parallel. To access it:

import worker_threads from 'node:worker_threads';

const worker_threads = require('node:worker_threads');

Workers (threads) are useful for performing CPU-intensive JavaScript operations. They do not help much with I/O-intensive work. The Node.js built-in asynchronous I/O operations are more efficient than Workers can be.

Unlike child_process or cluster, worker_threads can share memory. They do so by transferring ArrayBuffer instances or sharing SharedArrayBuffer instances.

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

if (!isMainThread) {
  const { parse } = await import('some-js-parsing-library');
  const script = workerData;
  parentPort.postMessage(parse(script));
}

export default function parseJSAsync(script) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(new URL(import.meta.url), {
      workerData: script,
    });
    worker.on('message', resolve);
    worker.once('error', reject);
    worker.once('exit', (code) => {
      if (code !== 0)
        reject(new Error(`Worker stopped with exit code ${code}`));
    });
  });
};

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

if (isMainThread) {
  module.exports = function parseJSAsync(script) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, {
        workerData: script,
      });
      worker.on('message', resolve);
      worker.once('error', reject);
      worker.once('exit', (code) => {
        if (code !== 0)
          reject(new Error(`Worker stopped with exit code ${code}`));
      });
    });
  };
} else {
  const { parse } = require('some-js-parsing-library');
  const script = workerData;
  parentPort.postMessage(parse(script));
}

The above example spawns a Worker thread for each parseJSAsync() call. In practice, use a pool of Workers for these kinds of tasks. Otherwise, the overhead of creating Workers would likely exceed their benefit.

When implementing a worker pool, use the [AsyncResource][] API to inform diagnostic tools (e.g. to provide asynchronous stack traces) about the correlation between tasks and their outcomes. See [“Using AsyncResource for a Worker thread pool”][async-resource-worker-pool] in the async_hooks documentation for an example implementation.

Worker threads inherit non-process-specific options by default. Refer to [Worker constructor options][] to know how to customize worker thread options, specifically argv and execArgv options.

`worker_threads.getEnvironmentData(key)`

key {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.
Returns: {any}

Within a worker thread, worker.getEnvironmentData() returns a clone of data passed to the spawning thread's worker.setEnvironmentData(). Every new Worker receives its own copy of the environment data automatically.

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!'.
}

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!'.
}

`worker_threads.isInternalThread`

Type: {boolean}

Is true if this code is running inside of an internal [Worker][] thread (e.g the loader thread).

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

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

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

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

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

`worker_threads.isMainThread`

Type: {boolean}

Is true if this code is not running inside of a [Worker][] thread.

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'.
}

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'.
}

`worker_threads.markAsUntransferable(object)`

object {any} Any arbitrary JavaScript value.

Mark an object as not transferable. If object occurs in the transfer list of a [port.postMessage()][] call, an error is thrown. This is a no-op if object is a primitive value.

In particular, this makes sense for objects that can be cloned, rather than transferred, and which are used by other objects on the sending side. For example, Node.js marks the ArrayBuffers it uses for its [Buffer pool][Buffer.allocUnsafe()] with this. ArrayBuffer.prototype.transfer() is disallowed on such array buffer instances.

This operation cannot be undone.

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);

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);

There is no equivalent to this API in browsers.

`worker_threads.isMarkedAsUntransferable(object)`

object {any} Any JavaScript value.
Returns: {boolean}

Check if an object is marked as not transferable with [markAsUntransferable()][].

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

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

isMarkedAsUntransferable(pooledBuffer);  // Returns true.

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

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

isMarkedAsUntransferable(pooledBuffer);  // Returns true.

There is no equivalent to this API in browsers.

`worker_threads.markAsUncloneable(object)`

object {any} Any arbitrary JavaScript value.

Mark an object as not cloneable. If object is used as message in a [port.postMessage()][] call, an error is thrown. This is a no-op if object is a primitive value.

This has no effect on ArrayBuffer, or any Buffer like objects.

This operation cannot be undone.

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'
}

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'
}

There is no equivalent to this API in browsers.

`worker_threads.moveMessagePortToContext(port, contextifiedSandbox)`

port {MessagePort} The message port to transfer.
contextifiedSandbox {Object} A [contextified][] object as returned by the vm.createContext() method.
Returns: {MessagePort}

Transfer a MessagePort to a different [vm][] Context. The original port object is rendered unusable, and the returned MessagePort instance takes its place.

The returned MessagePort is an object in the target context and inherits from its global Object class. Objects passed to the [port.onmessage()][] listener are also created in the target context and inherit from its global Object class.

However, the created MessagePort no longer inherits from {EventTarget}, and only [port.onmessage()][] can be used to receive events using it.

`worker_threads.parentPort`

Type: {null|MessagePort}

If this thread is a [Worker][], this is a [MessagePort][] allowing communication with the parent thread. Messages sent using parentPort.postMessage() are available in the parent thread using worker.on('message'), and messages sent from the parent thread using worker.postMessage() are available in this thread using 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);
  });
}

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);
  });
}

`worker_threads.postMessageToThread(threadId, value[, transferList][, timeout])`

Stability: 1.1 - Active development

threadId {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 postMessageToThread: it creates 10 nested threads, the last one will try to communicate with the main thread.

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;

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;

`worker_threads.receiveMessageOnPort(port)`

port {MessagePort|BroadcastChannel}
Returns: {Object|undefined}

Receive a single message from a given MessagePort. If no message is available, undefined is returned, otherwise an object with a single message property that contains the message payload, corresponding to the oldest message in the MessagePort's queue.

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

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: undefined

When this function is used, no 'message' event is emitted and the onmessage listener is not invoked.

`worker_threads.resourceLimits`

Type: {Object}
maxYoungGenerationSizeMb {number}
maxOldGenerationSizeMb {number}
codeRangeSizeMb {number}
stackSizeMb {number}

Provides the set of JS engine resource constraints inside this Worker thread. If the resourceLimits option was passed to the [Worker][] constructor, this matches its values.

If this is used in the main thread, its value is an empty object.

`worker_threads.SHARE_ENV`

Type: {symbol}

A special value that can be passed as the env option of the [Worker][] constructor, to indicate that the current thread and the Worker thread should share read and write access to the same set of environment variables.

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 })
  .once('exit', () => {
    console.log(process.env.SET_IN_WORKER);  // Prints 'foo'.
  });

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

`worker_threads.setEnvironmentData(key[, value])`

key {any} Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.
value {any} Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new Worker instances. If value is passed as undefined, any previously set value for the key will be deleted.

The worker.setEnvironmentData() API sets the content of worker.getEnvironmentData() in the current thread and all new Worker instances spawned from the current context.

`worker_threads.threadId`

Type: {integer}

An integer identifier for the current thread. On the corresponding worker object (if there is any), it is available as [worker.threadId][]. This value is unique for each [Worker][] instance inside a single process.

`worker_threads.threadName`

{string|null}

A string identifier for the current thread or null if the thread is not running. On the corresponding worker object (if there is any), it is available as [worker.threadName][].

`worker_threads.workerData`

An arbitrary JavaScript value that contains a clone of the data passed to this thread's Worker constructor.

The data is cloned as if using [postMessage()][port.postMessage()], according to the [HTML structured clone algorithm][].

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!'.
}

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!'.
}

`worker_threads.locks`

Stability: 1 - Experimental

{LockManager}

An instance of a [LockManager][LockManager] that can be used to coordinate access to resources that may be shared across multiple threads within the same process. The API mirrors the semantics of the [browser LockManager][]

Class: `Lock`

The Lock interface provides information about a lock that has been granted via [locks.request()][locks.request()]

`lock.name`

{string}

The name of the lock.

`lock.mode`

{string}

The mode of the lock. Either shared or exclusive.

Class: `LockManager`

The LockManager interface provides methods for requesting and introspecting locks. To obtain a LockManager instance use

import { locks } from 'node:worker_threads';

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

This implementation matches the [browser LockManager][] API.

`locks.request(name[, options], callback)`

name {string}
options {Object}
mode {string} Either 'exclusive' or 'shared'. Default: 'exclusive'.
ifAvailable {boolean} If true, the request will only be granted if the lock is not already held. If it cannot be granted, callback will be invoked with null instead of a Lock instance. Default: false.
steal {boolean} If true, any existing locks with the same name are released and the request is granted immediately, pre-empting any queued requests. Default: false.
signal {AbortSignal} that can be used to abort a pending (but not yet granted) lock request.
callback {Function} Invoked once the lock is granted (or immediately with null if ifAvailable is true and the lock is unavailable). The lock is released automatically when the function returns, or—if the function returns a promise—when that promise settles.
Returns: {Promise} Resolves once the lock has been released.

import { locks } from 'node:worker_threads';

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

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

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

`locks.query()`

Returns: {Promise}

Resolves with a LockManagerSnapshot describing the currently held and pending locks for the current process.

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}`);
}

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}`);
  }
});

Class: `BroadcastChannel extends EventTarget`

Instances of BroadcastChannel allow asynchronous one-to-many communication with all other BroadcastChannel instances bound to the same channel name.

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();
}

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();
}

`new BroadcastChannel(name)`

name {any} The name of the channel to connect to. Any JavaScript value that can be converted to a string using `${name}` is permitted.

`broadcastChannel.close()`

Closes the BroadcastChannel connection.

`broadcastChannel.onmessage`

Type: {Function} Invoked with a single MessageEvent argument when a message is received.

`broadcastChannel.onmessageerror`

Type: {Function} Invoked with a received message cannot be deserialized.

`broadcastChannel.postMessage(message)`

message {any} Any cloneable JavaScript value.

`broadcastChannel.ref()`

Opposite of unref(). Calling ref() on a previously unref()ed BroadcastChannel does not let the program exit if it's the only active handle left (the default behavior). If the port is ref()ed, calling ref() again has no effect.

`broadcastChannel.unref()`

Calling unref() on a BroadcastChannel allows the thread to exit if this is the only active handle in the event system. If the BroadcastChannel is already unref()ed calling unref() again has no effect.

Class: `MessageChannel`

Instances of the worker.MessageChannel class represent an asynchronous, two-way communications channel. The MessageChannel has no methods of its own. new MessageChannel() yields an object with port1 and port2 properties, which refer to linked [MessagePort][] instances.

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

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')` listener

Class: `MessagePort`

Extends: {EventTarget}

Instances of the worker.MessagePort class represent one end of an asynchronous, two-way communications channel. It can be used to transfer structured data, memory regions and other MessagePorts between different [Worker][]s.

This implementation matches [browser MessagePort][]s.

Event: `'close'`

The 'close' event is emitted once either side of the channel has been disconnected.

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

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

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

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

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

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

Event: `'message'`

value {any} The transmitted value

The 'message' event is emitted for any incoming message, containing the cloned input of [port.postMessage()][].

Listeners on this event receive a clone of the value parameter as passed to postMessage() and no further arguments.

Event: `'messageerror'`

error {Error} An Error object

The 'messageerror' event is emitted when deserializing a message failed.

Currently, this event is emitted when there is an error occurring while instantiating the posted JS object on the receiving end. Such situations are rare, but can happen, for instance, when certain Node.js API objects are received in a vm.Context (where Node.js APIs are currently unavailable).

`port.close()`

Disables further sending of messages on either side of the connection. This method can be called when no further communication will happen over this MessagePort.

The ['close' event][] is emitted on both MessagePort instances that are part of the channel.

`port.postMessage(value[, transferList])`

value {any}
transferList {Object[]}

Sends a JavaScript value to the receiving side of this channel. value is transferred in a way which is compatible with the [HTML structured clone algorithm][].

In particular, the significant differences to JSON are:

value may contain circular references.
value may contain instances of builtin JS types such as RegExps, BigInts, Maps, Sets, etc.
value may contain typed arrays, both using ArrayBuffers and SharedArrayBuffers.
value may contain [WebAssembly.Module][] instances.
value may not contain native (C++-backed) objects other than:
{CryptoKey}s,
{FileHandle}s,
{Histogram}s,
{KeyObject}s,
{MessagePort}s,
{net.BlockList}s,
{net.Server}s (TCP only, when listed in transferList),
{net.Socket}s (TCP only, when listed in transferList),
{net.SocketAddress}es,
{X509Certificate}s.

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);

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);

transferList may be a list of {ArrayBuffer}, [MessagePort][], [FileHandle][], {net.Server}, {net.Socket}, and {net.BoundSocket} objects. After transferring, they are not usable on the sending side of the channel anymore (even if they are not contained in value).

Transferring a {net.Server} moves its listening socket — together with any pending connections in the accept queue — to the receiving thread's event loop. Transferring a {net.Socket} moves a single connection; the socket must be a freshly accepted or created TCP connection that has not yet started reading and has no buffered data, otherwise postMessage() throws ERR_WORKER_HANDLE_NOT_TRANSFERABLE. This makes it possible to accept connections on one thread and distribute them across a pool of worker threads. Transferring a {net.BoundSocket} moves an un-adopted pre-bound socket, so a port can be reserved synchronously on one thread and adopted on another. Only TCP handles are supported.

If value contains {SharedArrayBuffer} instances, those are accessible from either thread. They cannot be listed in transferList.

value may still contain ArrayBuffer instances that are not in transferList; in that case, the underlying memory is copied rather than moved.

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 ]);

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 ]);

The message object is cloned immediately, and can be modified after posting without having side effects.

For more information on the serialization and deserialization mechanisms behind this API, see the [serialization API of the node:v8 module][v8.serdes].

Considerations when transferring TypedArrays and Buffers

All {TypedArray|Buffer} instances are views over an underlying {ArrayBuffer}. That is, it is the ArrayBuffer that actually stores the raw data while the TypedArray and Buffer objects provide a way of viewing and manipulating the data. It is possible and common for multiple views to be created over the same ArrayBuffer instance. Great care must be taken when using a transfer list to transfer an ArrayBuffer as doing so causes all TypedArray and Buffer instances that share that same ArrayBuffer to become unusable.

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

For Buffer instances, specifically, whether the underlying ArrayBuffer can be transferred or cloned depends entirely on how instances were created, which often cannot be reliably determined.

An ArrayBuffer can be marked with [markAsUntransferable()][] to indicate that it should always be cloned and never transferred.

Depending on how a Buffer instance was created, it may or may not own its underlying ArrayBuffer. An ArrayBuffer must not be transferred unless it is known that the Buffer instance owns it. In particular, for Buffers created from the internal Buffer pool (using, for instance Buffer.from() or Buffer.allocUnsafe()), transferring them is not possible and they are always cloned, which sends a copy of the entire Buffer pool. This behavior may come with unintended higher memory usage and possible security concerns.

See [Buffer.allocUnsafe()][] for more details on Buffer pooling.

The ArrayBuffers for Buffer instances created using Buffer.alloc() or Buffer.allocUnsafeSlow() can always be transferred but doing so renders all other existing views of those ArrayBuffers unusable.

Considerations when cloning objects with prototypes, classes, and accessors

Because object cloning uses the [HTML structured clone algorithm][], non-enumerable properties, property accessors, and object prototypes are not preserved. In particular, {Buffer} objects will be read as plain {Uint8Array}s on the receiving side, and instances of JavaScript classes will be cloned as plain JavaScript objects.

const b = Symbol('b');

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

  get d() { return this.#a + 3; }
}

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

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

port2.postMessage(new Foo());

// Prints: { c: 3 }

Some built-in objects cannot be cloned at all. For example, posting a URL object throws a DataCloneError:

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

port2.postMessage(new URL('https://example.org'));
// Throws DataCloneError: Cannot clone object of unsupported type.

`port.hasRef()`

Returns: {boolean}

If true, the MessagePort object will keep the Node.js event loop active.

`port.ref()`

Opposite of unref(). Calling ref() on a previously unref()ed port does not let the program exit if it's the only active handle left (the default behavior). If the port is ref()ed, calling ref() again has no effect.

If listeners are attached or removed using .on('message'), the port is ref()ed and unref()ed automatically depending on whether listeners for the event exist.

`port.start()`

Starts receiving messages on this MessagePort. When using this port as an event emitter, this is called automatically once 'message' listeners are attached.

This method exists for parity with the Web MessagePort API. In Node.js, it is only useful for ignoring messages when no event listener is present. Node.js also diverges in its handling of .onmessage. Setting it automatically calls .start(), but unsetting it lets messages queue up until a new handler is set or the port is discarded.

`port.unref()`

Calling unref() on a port allows the thread to exit if this is the only active handle in the event system. If the port is already unref()ed calling unref() again has no effect.

If listeners are attached or removed using .on('message'), the port is ref()ed and unref()ed automatically depending on whether listeners for the event exist.

Class: `Worker`

Extends: {EventEmitter}

The Worker class represents an independent JavaScript execution thread. Most Node.js APIs are available inside of it.

Notable differences inside a Worker environment are:

The [process.stdin][], [process.stdout][], and [process.stderr][] streams may be redirected by the parent thread.
The [require('node:worker_threads').isMainThread][] property is set to false.
The [require('node:worker_threads').parentPort][] message port is available.
[process.exit()][] does not stop the whole program, just the single thread, and [process.abort()][] is not available.
[process.chdir()][] and process methods that set group or user ids are not available.
[process.env][] is a copy of the parent thread's environment variables, unless otherwise specified. Changes to one copy are not visible in other threads, and are not visible to native add-ons (unless [worker.SHARE_ENV][] is passed as the env option to the [Worker][] constructor). On Windows, unlike the main thread, a copy of the environment variables operates in a case-sensitive manner.
[process.title][] cannot be modified.
Signals are not delivered through [process.on('...')][Signals events].
Execution may stop at any point as a result of [worker.terminate()][] being invoked.
IPC channels from parent processes are not accessible.
The [trace_events][] module is not supported.
Native add-ons can only be loaded from multiple threads if they fulfill [certain conditions][Addons worker support].

Creating Worker instances inside of other Workers is possible.

Like [Web Workers][] and the [node:cluster module][], two-way communication can be achieved through inter-thread message passing. Internally, a Worker has a built-in pair of [MessagePort][]s that are already associated with each other when the Worker is created. While the MessagePort object on the parent side is not directly exposed, its functionalities are exposed through [worker.postMessage()][] and the [worker.on('message')][] event on the Worker object for the parent thread.

To create custom messaging channels (which is encouraged over using the default global channel because it facilitates separation of concerns), users can create a MessageChannel object on either thread and pass one of the MessagePorts on that MessageChannel to the other thread through a pre-existing channel, such as the global one.

See [port.postMessage()][] for more information on how messages are passed, and what kind of JavaScript values can be successfully transported through the thread barrier.

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();
  });
}

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();
  });
}

`new Worker(filename[, options])`

<!-- YAML added: v10.5.0 changes: - version: - v19.8.0 - v18.16.0 pr-url: https://github.com/nodejs/node/pull/46832 description: Added support for a name option, which allows adding a name to worker title for debugging. - version: v14.9.0 pr-url: htt

（本文超出站点单文档体积上限，已截断）

Worker threads

Worker threads

worker_threads.getEnvironmentData(key)

worker_threads.isInternalThread

worker_threads.isMainThread

worker_threads.markAsUntransferable(object)

worker_threads.isMarkedAsUntransferable(object)

worker_threads.markAsUncloneable(object)

worker_threads.moveMessagePortToContext(port, contextifiedSandbox)

worker_threads.parentPort

worker_threads.postMessageToThread(threadId, value[, transferList][, timeout])

worker_threads.receiveMessageOnPort(port)

worker_threads.resourceLimits

worker_threads.SHARE_ENV

worker_threads.setEnvironmentData(key[, value])

worker_threads.threadId

worker_threads.threadName

worker_threads.workerData

worker_threads.locks

Class: Lock

lock.name

lock.mode

Class: LockManager

locks.request(name[, options], callback)

locks.query()

Class: BroadcastChannel extends EventTarget

new BroadcastChannel(name)

broadcastChannel.close()

broadcastChannel.onmessage

broadcastChannel.onmessageerror

broadcastChannel.postMessage(message)

broadcastChannel.ref()

broadcastChannel.unref()

Class: MessageChannel

Class: MessagePort

Event: 'close'

Event: 'message'

Event: 'messageerror'

port.close()

port.postMessage(value[, transferList])

Considerations when transferring TypedArrays and Buffers

Considerations when cloning objects with prototypes, classes, and accessors

port.hasRef()

port.ref()

port.start()

port.unref()

Class: Worker

new Worker(filename[, options])

`worker_threads.getEnvironmentData(key)`

`worker_threads.isInternalThread`

`worker_threads.isMainThread`

`worker_threads.markAsUntransferable(object)`

`worker_threads.isMarkedAsUntransferable(object)`

`worker_threads.markAsUncloneable(object)`

`worker_threads.moveMessagePortToContext(port, contextifiedSandbox)`

`worker_threads.parentPort`

`worker_threads.postMessageToThread(threadId, value[, transferList][, timeout])`

`worker_threads.receiveMessageOnPort(port)`

`worker_threads.resourceLimits`

`worker_threads.SHARE_ENV`

`worker_threads.setEnvironmentData(key[, value])`

`worker_threads.threadId`

`worker_threads.threadName`

`worker_threads.workerData`

`worker_threads.locks`

Class: `Lock`

`lock.name`

`lock.mode`

Class: `LockManager`

`locks.request(name[, options], callback)`

`locks.query()`

Class: `BroadcastChannel extends EventTarget`

`new BroadcastChannel(name)`

`broadcastChannel.close()`

`broadcastChannel.onmessage`

`broadcastChannel.onmessageerror`

`broadcastChannel.postMessage(message)`

`broadcastChannel.ref()`

`broadcastChannel.unref()`

Class: `MessageChannel`

Class: `MessagePort`

Event: `'close'`

Event: `'message'`

Event: `'messageerror'`

`port.close()`

`port.postMessage(value[, transferList])`

`port.hasRef()`

`port.ref()`

`port.start()`

`port.unref()`

Class: `Worker`

`new Worker(filename[, options])`