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 cloneof data passed to the spawning thread'sworker.setEnvironmentData().Every newWorker receives its own copy of the environment dataautomatically.

import {Worker,  isMainThread,  setEnvironmentData,  getEnvironmentData,}from'node:worker_threads';if (isMainThread) {setEnvironmentData('Hello','World!');const worker =newWorker(newURL(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 =newWorker(__filename);}else {console.log(getEnvironmentData('Hello'));// Prints 'World!'.}copy

worker_threads.isInternalThread#

• Type:<boolean>

Istrue if this code is running inside of an internalWorker thread (e.g the loader thread).

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

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

// main.jsimport { 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#

• Type:<boolean>

Istrue if this code is not running inside of aWorker thread.

import {Worker, isMainThread }from'node:worker_threads';if (isMainThread) {// This re-loads the current file inside a Worker instance.newWorker(newURL(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.newWorker(__filename);}else {console.log('Inside Worker!');console.log(isMainThread);// Prints 'false'.}copy

worker_threads.markAsUntransferable(object)#

• object<any> Any arbitrary JavaScript value.

Mark an object as not transferable. Ifobject occurs in the transfer list ofaport.postMessage() call, an error is thrown. This is a no-op ifobject is a primitive value.

In particular, this makes sense for objects that can be cloned, rather thantransferred, and which are used by other objects on the sending side.For example, Node.js marks theArrayBuffers it uses for itsBuffer pool with this.

This operation cannot be undone.

import {MessageChannel, markAsUntransferable }from'node:worker_threads';const pooledBuffer =newArrayBuffer(8);const typedArray1 =newUint8Array(pooledBuffer);const typedArray2 =newFloat64Array(pooledBuffer);markAsUntransferable(pooledBuffer);const { port1 } =newMessageChannel();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 =newArrayBuffer(8);const typedArray1 =newUint8Array(pooledBuffer);const typedArray2 =newFloat64Array(pooledBuffer);markAsUntransferable(pooledBuffer);const { port1 } =newMessageChannel();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

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 withmarkAsUntransferable().

import { markAsUntransferable, isMarkedAsUntransferable }from'node:worker_threads';const pooledBuffer =newArrayBuffer(8);markAsUntransferable(pooledBuffer);isMarkedAsUntransferable(pooledBuffer);// Returns true.'use strict';const { markAsUntransferable, isMarkedAsUntransferable } =require('node:worker_threads');const pooledBuffer =newArrayBuffer(8);markAsUntransferable(pooledBuffer);isMarkedAsUntransferable(pooledBuffer);// Returns true.copy

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. Ifobject is used asmessage inaport.postMessage() call, an error is thrown. This is a no-op ifobject is aprimitive value.

This has no effect onArrayBuffer, or anyBuffer like objects.

This operation cannot be undone.

import { markAsUncloneable }from'node:worker_threads';const anyObject = {foo:'bar' };markAsUncloneable(anyObject);const { port1 } =newMessageChannel();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 } =newMessageChannel();try {// This will throw an error, because anyObject is not cloneable.  port1.postMessage(anyObject);}catch (error) {// error.name === 'DataCloneError'}copy

There is no equivalent to this API in browsers.

worker_threads.moveMessagePortToContext(port, contextifiedSandbox)#

• port<MessagePort> The message port to transfer.

• contextifiedSandbox<Object> Acontextified object as returned by thevm.createContext() method.

• Returns:<MessagePort>

Transfer aMessagePort to a differentvm Context. The originalportobject is rendered unusable, and the returnedMessagePort instancetakes its place.

The returnedMessagePort is an object in the target context andinherits from its globalObject class. Objects passed to theport.onmessage() listener are also created in the target contextand inherit from its globalObject class.

However, the createdMessagePort no longer inherits from<EventTarget>, and onlyport.onmessage() can be used to receiveevents using it.

worker_threads.parentPort#

• Type:<null> |<MessagePort>

If this thread is aWorker, this is aMessagePortallowing communication with the parent thread. Messages sent usingparentPort.postMessage() are available in the parent threadusingworker.on('message'), and messages sent from the parent threadusingworker.postMessage() are available in this thread usingparentPort.on('message').

import {Worker, isMainThread, parentPort }from'node:worker_threads';if (isMainThread) {const worker =newWorker(newURL(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 =newWorker(__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> The target thread ID. If the thread ID is invalid, aERR_WORKER_MESSAGING_FAILED error will be thrown. If the target thread ID is the current thread ID,aERR_WORKER_MESSAGING_SAME_THREAD error will be thrown.
• value<any> The value to send.
• transferList<Object[]> If one or moreMessagePort-like objects are passed invalue,atransferList is required for those items orERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST is thrown.Seeport.postMessage() for more information.
• timeout<number> Time to wait for the message to be delivered in milliseconds.By default it'sundefined, which means wait forever. If the operation times out,aERR_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 theworkerMessage event, then the operation will throwaERR_WORKER_MESSAGING_FAILED error.

If the target thread threw an error while processing theworkerMessage event, then the operation will throwaERR_WORKER_MESSAGING_ERRORED error.

This method should be used when the target thread is not the directparent or child of the current thread.If the two threads are parent-children, use therequire('node:worker_threads').parentPort.postMessage()and theworker.postMessage() to let the threads communicate.

The example below shows the use of ofpostMessageToThread: it creates 10 nested threads,the last one will try to communicate with the main thread.

import processfrom'node:process';import {  postMessageToThread,  threadId,  workerData,Worker,}from'node:worker_threads';const channel =newBroadcastChannel('sync');const level = workerData?.level ??0;if (level <10) {const worker =newWorker(newURL(import.meta.url), {workerData: {level: level +1 },  });}if (level ===0) {  process.on('workerMessage',(value, source) => {console.log(`${source} ->${threadId}:`, value);postMessageToThread(source, {message:'pong' });  });}elseif (level ===10) {  process.on('workerMessage',(value, source) => {console.log(`${source} ->${threadId}:`, value);    channel.postMessage('done');    channel.close();  });awaitpostMessageToThread(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 =newBroadcastChannel('sync');const level = workerData?.level ??0;if (level <10) {const worker =newWorker(__filename, {workerData: {level: level +1 },  });}if (level ===0) {  process.on('workerMessage',(value, source) => {console.log(`${source} ->${threadId}:`, value);postMessageToThread(source, {message:'pong' });  });}elseif (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>

• Returns:<Object> |<undefined>

Receive a single message from a givenMessagePort. If no message is available,undefined is returned, otherwise an object with a singlemessage propertythat contains the message payload, corresponding to the oldest message in theMessagePort's queue.

import {MessageChannel, receiveMessageOnPort }from'node:worker_threads';const { port1, port2 } =newMessageChannel();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 } =newMessageChannel();port1.postMessage({hello:'world' });console.log(receiveMessageOnPort(port2));// Prints: { message: { hello: 'world' } }console.log(receiveMessageOnPort(port2));// Prints: undefinedcopy

When this function is used, no'message' event is emitted and theonmessage 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 theresourceLimits option was passed to theWorker 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 theenv option of theWorkerconstructor, to indicate that the current thread and the Worker thread shouldshare read and write access to the same set of environment variables.

import processfrom'node:process';import {Worker,SHARE_ENV }from'node:worker_threads';newWorker('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');newWorker('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> Any arbitrary, cloneable JavaScript value that can be used as a<Map> key.
• value<any> Any arbitrary, cloneable JavaScript value that will be clonedand passed automatically to all newWorker instances. Ifvalue is passedasundefined, any previously set value for thekey will be deleted.

Theworker.setEnvironmentData() API sets the content ofworker.getEnvironmentData() in the current thread and all newWorkerinstances 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 asworker.threadId.This value is unique for eachWorker 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 asworker.threadName.

worker_threads.workerData#

An arbitrary JavaScript value that contains a clone of the data passedto this thread'sWorker constructor.

The data is cloned as if usingpostMessage(),according to theHTML structured clone algorithm.

import {Worker, isMainThread, workerData }from'node:worker_threads';if (isMainThread) {const worker =newWorker(newURL(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 =newWorker(__filename, {workerData:'Hello, world!' });}else {console.log(workerData);// Prints 'Hello, world!'.}copy

worker_threads.locks#

• <LockManager>

An instance of aLockManager that can be used to coordinateaccess to resources that may be shared across multiple threads within the sameprocess. The API mirrors the semantics of thebrowserLockManager

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 lockof snapshot.held) {console.log(`held lock: name${lock.name}, mode${lock.mode}`);}for (const pendingof 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 lockof snapshot.held) {console.log(`held lock: name${lock.name}, mode${lock.mode}`);  }for (const pendingof snapshot.pending) {console.log(`pending lock: name${pending.name}, mode${pending.mode}`);  }});copy

Class:BroadcastChannel extends EventTarget#

Instances ofBroadcastChannel allow asynchronous one-to-many communicationwith all otherBroadcastChannel instances bound to the same channel name.

import {  isMainThread,BroadcastChannel,Worker,}from'node:worker_threads';const bc =newBroadcastChannel('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++)newWorker(newURL(import.meta.url));}else {  bc.postMessage('hello from every worker');  bc.close();}'use strict';const {  isMainThread,BroadcastChannel,Worker,} =require('node:worker_threads');const bc =newBroadcastChannel('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++)newWorker(__filename);}else {  bc.postMessage('hello from every worker');  bc.close();}copy

Class:MessageChannel#

Instances of theworker.MessageChannel class represent an asynchronous,two-way communications channel.TheMessageChannel has no methods of its own.new MessageChannel()yields an object withport1 andport2 properties, which refer to linkedMessagePort instances.

import {MessageChannel }from'node:worker_threads';const { port1, port2 } =newMessageChannel();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 } =newMessageChannel();port1.on('message',(message) =>console.log('received', message));port2.postMessage({foo:'bar' });// Prints: received { foo: 'bar' } from the `port1.on('message')` listenercopy

Class:MessagePort#

• Extends:<EventTarget>

Instances of theworker.MessagePort class represent one end of anasynchronous, two-way communications channel. It can be used to transferstructured data, memory regions and otherMessagePorts between differentWorkers.

This implementation matchesbrowserMessagePorts.

import {MessageChannel }from'node:worker_threads';const { port1, port2 } =newMessageChannel();// 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 } =newMessageChannel();// 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 } =newMessageChannel();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 } =newMessageChannel();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 } =newMessageChannel();port1.on('message',(message) =>console.log(message));const uint8Array =newUint8Array([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 =newUint8Array(newSharedArrayBuffer(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 =newMessageChannel();port2.postMessage({port: otherChannel.port1 }, [ otherChannel.port1 ]);'use strict';const {MessageChannel } =require('node:worker_threads');const { port1, port2 } =newMessageChannel();port1.on('message',(message) =>console.log(message));const uint8Array =newUint8Array([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 =newUint8Array(newSharedArrayBuffer(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 =newMessageChannel();port2.postMessage({port: otherChannel.port1 }, [ otherChannel.port1 ]);copy

const ab =newArrayBuffer(10);const u1 =newUint8Array(ab);const u2 =newUint16Array(ab);console.log(u2.length);// prints 5port.postMessage(u1, [u1.buffer]);console.log(u2.length);// prints 0copy

const b =Symbol('b');classFoo {  #a =1;constructor() {this[b] =2;this.c =3;  }getd() {return4; }}const { port1, port2 } =newMessageChannel();port1.onmessage =({ data }) =>console.log(data);port2.postMessage(newFoo());// Prints: { c: 3 }copy

const { port1, port2 } =newMessageChannel();port1.onmessage =({ data }) =>console.log(data);port2.postMessage(newURL('https://example.org'));// Prints: { }copy

Class:Worker#

• Extends:<EventEmitter>

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

Notable differences inside a Worker environment are:

• Theprocess.stdin,process.stdout, andprocess.stderrstreams may be redirected by the parent thread.
• Therequire('node:worker_threads').isMainThread property is set tofalse.
• Therequire('node:worker_threads').parentPort message port is available.
• process.exit() does not stop the whole program, just the single thread,andprocess.abort() is not available.
• process.chdir() andprocess methods that set group or user idsare 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 otherthreads, and are not visible to native add-ons (unlessworker.SHARE_ENV is passed as theenv option to theWorker constructor). On Windows, unlike the main thread, a copy of theenvironment variables operates in a case-sensitive manner.
• process.title cannot be modified.
• Signals are not delivered throughprocess.on('...').
• Execution may stop at any point as a result ofworker.terminate()being invoked.
• IPC channels from parent processes are not accessible.
• Thetrace_events module is not supported.
• Native add-ons can only be loaded from multiple threads if they fulfillcertain conditions.

CreatingWorker instances inside of otherWorkers is possible.

LikeWeb Workers and thenode:cluster module, two-way communicationcan be achieved through inter-thread message passing. Internally, aWorker hasa built-in pair ofMessagePorts that are already associated with eachother when theWorker is created. While theMessagePort object on the parentside is not directly exposed, its functionalities are exposed throughworker.postMessage() and theworker.on('message') eventon theWorker object for the parent thread.

To create custom messaging channels (which is encouraged over using the defaultglobal channel because it facilitates separation of concerns), users can createaMessageChannel object on either thread and pass one of theMessagePorts on thatMessageChannel to the other thread through apre-existing channel, such as the global one.

Seeport.postMessage() for more information on how messages are passed,and what kind of JavaScript values can be successfully transported throughthe thread barrier.

import assertfrom'node:assert';import {Worker,MessageChannel,MessagePort, isMainThread, parentPort,}from'node:worker_threads';if (isMainThread) {const worker =newWorker(newURL(import.meta.url));const subChannel =newMessageChannel();  worker.postMessage({hereIsYourPort: subChannel.port1 }, [subChannel.port1]);  subChannel.port2.on('message',(value) => {console.log('received:', value);  });}else {  parentPort.once('message',(value) => {assert(value.hereIsYourPortinstanceofMessagePort);    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 =newWorker(__filename);const subChannel =newMessageChannel();  worker.postMessage({hereIsYourPort: subChannel.port1 }, [subChannel.port1]);  subChannel.port2.on('message',(value) => {console.log('received:', value);  });}else {  parentPort.once('message',(value) => {assert(value.hereIsYourPortinstanceofMessagePort);    value.hereIsYourPort.postMessage('the worker is sending this');    value.hereIsYourPort.close();  });}copy

import {Worker, isMainThread, parentPort }from'node:worker_threads';if (isMainThread) {const worker =newWorker(newURL(import.meta.url));setInterval(() => {    worker.postMessage('hi');console.log(worker.performance.eventLoopUtilization());  },100).unref();}else {  parentPort.on('message',() =>console.log('msg')).unref();  (functionr(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 =newWorker(__filename);setInterval(() => {    worker.postMessage('hi');console.log(worker.performance.eventLoopUtilization());  },100).unref();}else {  parentPort.on('message',() =>console.log('msg')).unref();  (functionr(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 =newWorker(`  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 =newWorker(`  const { parentPort } = require('node:worker_threads');  parentPort.on('message', () => {});  `, {eval:true });w.on('online',async () => {// Stop profile automatically when return and profile will be discardedawaitusing handle =await w.startCpuProfile();});copy

const {Worker } =require('node:worker_threads');const worker =newWorker(`  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 =newWorker(`  const { parentPort } = require('node:worker_threads');  parentPort.on('message', () => {});  `, {eval:true });w.on('online',async () => {// Stop profile automatically when return and profile will be discardedawaitusing handle =await w.startHeapProfile();});copy

asyncfunctionexample() {awaitusing worker =newWorker('for (;;) {}', {eval:true });// Worker is automatically terminate when the scope is exited.}copy

Notes#

import {Worker,  isMainThread,}from'node:worker_threads';if (isMainThread) {newWorker(newURL(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) {newWorker(__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