Worker Threads

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

const worker = new Worker('./worker.js');
worker.postMessage({ hello: 'world' });

// Transfer an ArrayBuffer
const buffer = new ArrayBuffer(10);
worker.postMessage({ buffer }, [buffer]);
// buffer is now unusable in the parent

const worker = new Worker('./worker.js');
setTimeout(() => {
  worker.terminate();
}, 5000);

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

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 {
  parentPort.once('message', (message) => {
    parentPort.postMessage(message);
  });
}

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

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

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

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

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

const { port1 } = new MessageChannel();
try {
  port1.postMessage(new Uint8Array(pooledBuffer), [pooledBuffer]);
} catch (error) {
  // error.name === 'DataCloneError'
}

import { markAsUncloneable, MessageChannel } from 'node:worker_threads';

const anyObject = { foo: 'bar' };
markAsUncloneable(anyObject);

const { port1 } = new MessageChannel();
try {
  port1.postMessage(anyObject);
} catch (error) {
  // error.name === 'DataCloneError'
}

import { postMessageToThread, threadId } from 'node:worker_threads';

process.on('workerMessage', (value, source) => {
  console.log(`${source} -> ${threadId}:`, value);
  postMessageToThread(source, { message: 'pong' });
});

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

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

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

import { locks } from 'node:worker_threads';

await locks.request('my_resource', async (lock) => {
  // The lock has been acquired
  // Perform work with the protected resource
});
// The lock has been released

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 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 - ArrayBuffer was transferred!

class Foo {
  #a = 1;
  get d() { return 4; }
}

port2.postMessage(new Foo());
// Receives: { c: 3 } - only enumerable properties

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) => {
    value.hereIsYourPort.postMessage('the worker is sending this');
    value.hereIsYourPort.close();
  });
}