Потоки обработки задач

Исходный код: lib/worker_threads.js

Модуль worker_threads позволяет использовать потоки, которые выполняют JavaScript параллельно. Для доступа к нему:

const worker = require('worker_threads');

Потоки (нити) полезны для выполнения ресурсоёмких JavaScript операций. Они не сильно помогут с работами, связанными с вводом-выводом. Встроенные в Node.js асинхронные операции ввода-вывода более эффективны, чем могут быть потоки.

В отличие от child_process или cluster, worker_threads могут совместно использовать память. Они делают это, передавая экземпляры ArrayBuffer или совместно используя экземпляры SharedArrayBuffer.

const {
  Worker, isMainThread, parentPort, workerData
} = require('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.on('error', reject);
      worker.on('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));
}

В приведенном выше примере для каждого вызова parse() запускается поток обработки задач. На практике для таких задач лучше использовать пул потоков обработки задач. В противном случае накладные расходы на создание потоков обработки задач могут превысить их преимущества.

При реализации пула потоков обработки задач используйте API AsyncResource для информирования средств диагностики (например, для предоставления асинхронных строк трассировки стека) о корреляции между задачами и их результатами. См. "Использование AsyncResource для пула потоков обработки задач" в документации async_hooks для примера реализации.

Потоки обработки задач по умолчанию наследуют параметры, не относящиеся к процессу. Обратитесь к Worker constructor options, чтобы узнать, как настроить параметры потоков обработки задач, в частности, параметры argv и execArgv.

worker.isMainThread

• <boolean>

Истинно, если этот код не выполняется внутри потока Worker.

const { Worker, isMainThread } = require('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.markAsUntransferable(object)

Отметить объект как непередаваемый. Если объект появляется в списке передачи вызова port.postMessage(), он будет пропущен.

Это особенно уместно для объектов, которые можно клонировать, а не передавать, и которые используются другими объектами на стороне отправителя. Например, Node.js помечает используемые им ArrayBuffer для своего Buffer пула таким образом.

Эта операция необратима.

const { MessageChannel, markAsUntransferable } = require('worker_threads');

const pooledBuffer = new ArrayBuffer(8);
const typedArray1 = new Uint8Array(pooledBuffer);
const typedArray2 = new Float64Array(pooledBuffer);

markAsUntransferable(pooledBuffer);

const { port1 } = new MessageChannel();
port1.postMessage(typedArray1, [ typedArray1.buffer ]);

// The following line prints the contents of typedArray1 -- it still owns
// its memory and has been cloned, not transferred. Without
// `markAsUntransferable()`, this would print an empty Uint8Array.
// typedArray2 is intact as well.
console.log(typedArray1);
console.log(typedArray2);

В браузерах нет эквивалентного API.

worker.moveMessagePortToContext(port, contextifiedSandbox)

• port <MessagePort> Порт сообщения, который будет передан.

• contextifiedSandbox <Object> Объект, контекстуализированный, возвращаемый методом vm.createContext().

• Возвращает: <MessagePort>

Передать MessagePort в другой vm контекст. Исходный объект port станет непригодным, а возвращённый экземпляр MessagePort займёт его место.

Возвращённый экземпляр MessagePort будет объектом в целевом контексте и унаследует от своего глобального класса Object. Объекты, переданные в слушатель port.onmessage(), также будут созданы в целевом контексте и унаследуют от его глобального класса Object.

Однако созданный экземпляр MessagePort больше не будет наследоваться от EventEmitter, и только port.onmessage() может использоваться для получения событий с его помощью.

worker.parentPort

• <null> | <MessagePort>

Если этот поток был запущен как Worker, это будет MessagePort, позволяющий общаться с родительским потоком. Сообщения, отправленные с помощью parentPort.postMessage() будут доступны в родительском потоке с помощью worker.on('message'), а сообщения, отправленные из родительского потока с помощью worker.postMessage() будут доступны в этом потоке с помощью parentPort.on('message').

const { Worker, isMainThread, parentPort } = require('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.receiveMessageOnPort(port)

• port <MessagePort>

• Возвращает: <Object> | <undefined>

Получить одно сообщение от заданного MessagePort. Если сообщений нет, возвращается undefined, иначе объект с единственным свойством message, содержащим полезную нагрузку сообщения, соответствующего самому старому сообщению в очереди MessagePort.

const { MessageChannel, receiveMessageOnPort } = require('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

При использовании этой функции не будет излучаться событие 'message' и слушатель onmessage не будет вызван.

worker.resourceLimits

• <Object>
  • maxYoungGenerationSizeMb <число>
  • maxOldGenerationSizeMb <число>
  • codeRangeSizeMb <число>
  • stackSizeMb <число>

Предоставляет набор ограничений ресурсов JS-движка внутри потока обработки задач. Если параметр resourceLimits был передан конструктору Worker, это соответствует его значениям.

Если это используется в основном потоке, его значение — пустой объект.

worker.SHARE_ENV

• <символ>

Особое значение, которое можно передать в качестве параметра env конструктора Worker, чтобы указать, что текущий поток и поток обработки задач должны совместно использовать чтение и запись в один и тот же набор переменных окружения.

const { Worker, SHARE_ENV } = require('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'.
  });

worker.threadId

• <целое число>

Целочисленный идентификатор текущего потока. В соответствующем объекте worker (если таковой имеется), он доступен как worker.threadId. Это значение уникально для каждого экземпляра Worker внутри одного процесса.

worker.workerData

Произвольное значение JavaScript, которое содержит клон данных, переданных в конструктор этого потока обработки задач Worker.

Данные клонируются так же, как если бы использовалась postMessage(), согласно алгоритму структурированного клонирования HTML.

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

if (isMainThread) {
  const worker = new Worker(__filename, { workerData: 'Hello, world!' });
} else {
  console.log(workerData);  // Prints 'Hello, world!'.
}

Класс: MessageChannel

Экземпляры класса worker.MessageChannel представляют собой асинхронный двусторонний канал связи. У класса MessageChannel нет собственных методов. new MessageChannel() возвращает объект со свойствами port1 и port2, которые ссылаются на связанные экземпляры MessagePort.

const { MessageChannel } = require('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

Класс: MessagePort

• Расширяет: <EventEmitter>

Экземпляры класса worker.MessagePort представляют собой один конец асинхронного двустороннего канала связи. Он может использоваться для передачи структурированных данных, областей памяти и других MessagePort между разными потоками обработки задач Worker.

За исключением того, что MessagePort являются экземплярами EventEmitter, а не EventTarget, эта реализация соответствует браузерным MessagePort.

Событие: 'close'

Событие 'close' излучается один раз, когда обе стороны канала были отключены.

const { MessageChannel } = require('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();

Событие: 'message'

• value <любое> Переданное значение

Событие 'message' излучается для любого входящего сообщения, содержащего клонированный вход port.postMessage().

Слушатели этого события получат клон параметра value в качестве переданного в postMessage() и никаких дополнительных аргументов.

Событие: 'messageerror'

• error <Ошибка> Объект Ошибка

Событие 'messageerror' срабатывает при неудачной десериализации сообщения.

port.close()

Отключает дальнейшую отправку сообщений с обеих сторон соединения. Этот метод можно вызвать, когда дальнейшее общение по этому MessagePort не произойдёт.

Событие 'close' событие будет выведено на обоих MessagePort экземплярах, которые являются частью канала.

port.postMessage(value[, transferList])

• value <любой>
• transferList <Массив объектов>

Отправляет значение JavaScript на принимающую сторону этого канала. value будет передано способом, совместимым с алгоритмом структурированного клонирования HTML.

В частности, существенные отличия от JSON:

• value может содержать циклические ссылки.
• value может содержать экземпляры встроенных типов JS, такие как RegExpы, BigIntы, Mapы, Setы и т.д.
• value может содержать типизированные массивы, как с использованием ArrayBufferов, так и SharedArrayBufferов.
• value может содержать экземпляры WebAssembly.Module.
• value не может содержать нативные (поддерживаемые C++) объекты, кроме MessagePortов, FileHandleов и KeyObjectов.

const { MessageChannel } = require('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 может быть списком ArrayBuffer, MessagePort и FileHandle объектов. После передачи они больше не будут доступны на стороне отправки канала (даже если они не содержатся в value). В отличие от процессов-потомков, передача дескрипторов, таких как сокеты, в настоящее время не поддерживается.

Если value содержит SharedArrayBuffer, то они будут доступны в любом потоке. Они не могут быть перечислены в transferList.

value может всё ещё содержать ArrayBuffer экземпляры, которые не в transferList; в этом случае основная память копируется, а не перемещается.

const { MessageChannel } = require('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` will be 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 ]);

Поскольку клонирование объектов использует алгоритм структурированного клонирования, неперечисляемые свойства, обработчики доступа к свойствам и прототипы объектов не сохраняются. В частности, Buffer объекты будут считаться простыми Uint8Array на принимающей стороне.

Объект сообщения будет клонирован немедленно, и может быть изменён после отправки без побочных эффектов.

Дополнительную информацию о механизмах сериализации и десериализации, лежащих в основе этого API, см. в API сериализации модуля v8.

Учёт при передаче TypedArrays и буферов

Все TypedArray и Buffer экземпляры являются представлениями над основной ArrayBuffer. То есть, именно ArrayBuffer фактически хранит сырые данные, в то время как TypedArray и Buffer объекты предоставляют способ просмотра и манипулирования данными. Возможно и часто встречается создание нескольких представлений над одним экземпляром ArrayBuffer. Необходимо быть предельно внимательным при использовании списка переноса для переноса ArrayBuffer, так как это приведёт к тому, что все TypedArray и Buffer экземпляры, использующие тот же ArrayBuffer, станут непригодны для использования.

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

Для Buffer экземпляров, в частности, возможность передачи или клонирования основного ArrayBuffer полностью зависит от того, как были созданы экземпляры, что часто невозможно надёжно определить.

Экземпляр ArrayBuffer может быть помечен с помощью markAsUntransferable(), чтобы указать, что он должен всегда клонироваться, а не передаваться.

В зависимости от способа создания экземпляра Buffer, он может или не может владеть своей основной ArrayBuffer. Экземпляр ArrayBuffer не должен передаваться, если не известно, что экземпляр Buffer его владеет. В частности, для Bufferов, созданных из внутренней пула Buffer (например, используя Buffer.from() или Buffer.alloc()), их передача невозможна, и они всегда будут клонироваться, что отправляет копию всего пула Buffer.

См. Buffer.allocUnsafe() для получения более подробной информации о пуле Buffer.

ArrayBuffer для Buffer экземпляров, созданных с использованием Buffer.alloc() или Buffer.allocUnsafeSlow(), всегда могут передаваться, но это сделает все другие существующие представления этих ArrayBuffer непригодными для использования.

port.ref()

Противоположность unref(). Вызов ref() на ранее unref()-ом порту не позволит программе выйти, если это единственная активная обработка (по умолчанию). Если порт ref()-ый, вызов ref() снова не будет иметь эффекта.

Если слушатели добавляются или удаляются с помощью .on('message'), порт будет ref()-ым и unref()-ым автоматически в зависимости от того, существуют ли слушатели для события.

port.start()

Начинает приём сообщений на этом MessagePort. При использовании этого порта как генератора событий, это будет вызываться автоматически, как только 'message' слушатели будут добавлены.

Этот метод существует для согласованности с API Web MessagePort. В Node.js он полезен только для игнорирования сообщений, когда нет слушателя события. Node.js также отличается в обработке .onmessage. Установка его автоматически вызовет .start(), но отмена установки позволит сообщениям очередиться до тех пор, пока не будет установлен новый обработчик или порт не будет удалён.

port.unref()

Вызов unref() на порту позволит потоку выйти, если это единственная активная обработка в системе событий. Если порт уже unref()-ый, вызов unref() снова не будет иметь эффекта.

Если слушатели добавляются или удаляются с помощью .on('message'), порт будет ref()-ым и unref()-ым автоматически в зависимости от того, существуют ли слушатели для события.

Класс: Worker

• Расширяет: <EventEmitter>

Класс Worker представляет собой независимый поток выполнения JavaScript. Внутри него доступны большинство API Node.js.

Существенные отличия в среде Worker:

• process.stdin, process.stdout и process.stderr могут быть перенаправлены родительским потоком.
• Свойство require('worker_threads').isMainThread установлено в false.
• Доступен порт сообщений require('worker_threads').parentPort.
• process.exit() не останавливает всю программу, только отдельный поток, и process.abort() недоступен.
• process.chdir() и методы, устанавливающие идентификаторы группы или пользователя, недоступны.
• process.env — копия переменных среды родительского потока, если не указано иное. Изменения в одной копии не будут видны в других потоках и не будут видны для нативных дополнений (если worker.SHARE_ENV не был передан в качестве параметра env конструктору Worker).
• process.title нельзя изменить.
• Сигналы не будут доставлены через process.on('...').
• Выполнение может остановиться в любой момент в результате вызова worker.terminate().
• Каналы IPC от родительских процессов недоступны.
• Модуль trace_events не поддерживается.
• Нативные дополнения могут загружаться только из нескольких потоков, если они удовлетворяют определённым условиям.

Создание экземпляров Worker внутри других Worker возможно.

Как и потоки веб-работы и модуль cluster, двунаправленная связь может быть реализована с помощью обмена сообщениями между потоками. Внутренне, в Worker есть встроенная пара MessagePort, которые уже связаны друг с другом при создании Worker. Хотя объект MessagePort на стороне родительского потока не экспортируется напрямую, его функциональность доступна через worker.postMessage() и событие worker.on('message') на объекте Worker родительского потока.

Для создания пользовательских каналов связи (что рекомендуется вместо использования глобального канала, так как это способствует разделению ответственности), пользователи могут создать объект MessageChannel в любом из потоков и передать один из MessagePort в этом MessageChannel в другой поток через существующий канал, такой как глобальный.

Дополнительную информацию о том, как передаются сообщения и какие типы значений JavaScript могут быть успешно переданы через барьер потоков, см. в разделе port.postMessage().

const assert = require('assert');
const {
  Worker, MessageChannel, MessagePort, isMainThread, parentPort
} = require('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])

• filename <строка> | <URL> Путь к основному скрипту или модулю потока-работы. Должен быть абсолютным или относительным путем (относительно текущей рабочей директории), начинающимся с ./ или ../, или объектом WHATWG URL с использованием протокола file:. Если options.eval равно true, это строка с кодом JavaScript, а не путем.
• options <Объект>
  • argv <любой массив> Список аргументов, которые будут преобразованы в строки и добавлены к process.argv в потоке-работе. В основном аналогично workerData, но значения будут доступны в глобальном process.argv так, как если бы они были переданы в качестве командной строки в скрипт.
  • env <Объект> Если задано, задаёт начальное значение process.env внутри потока-работы. В качестве специального значения можно использовать worker.SHARE_ENV, чтобы указать, что родительский и дочерний потоки должны совместно использовать свои переменные среды; в этом случае изменения в объекте process.env одного потока повлияют на другой поток. По умолчанию: process.env.
  • eval <булево> Если true и первый аргумент является string, интерпретировать первый аргумент конструктора как скрипт, который выполняется, когда поток-работа становится активным.
  • execArgv <массив строк> Список опций командной строки Node, передаваемых потоку-работе. Опции V8 (такие как --max-old-space-size) и опции, влияющие на процесс (такие как --title) не поддерживаются. Если задано, это будет предоставлено как process.execArgv внутри потока-работы. По умолчанию опции наследуются от родительского потока.
  • stdin <булево> Если это установлено в значение true, то worker.stdin предоставит поток для записи, содержимое которого будет отображаться как process.stdin внутри потока-работы. По умолчанию данные не предоставляются.
  • stdout <булево> Если это установлено в значение true, то worker.stdout не будет автоматически перенаправлен в process.stdout родительского потока.
  • stderr <булево> Если это установлено в значение true, то worker.stderr не будет автоматически перенаправлен в process.stderr родительского потока.
  • workerData <любое> Любое значение JavaScript, которое будет скопировано и доступно как require('worker_threads').workerData. Клонирование будет происходить в соответствии с алгоритмом структурированного клонирования HTML, и будет выброшено исключение, если объект не может быть клонирован (например, если он содержит function).
  • trackUnmanagedFds <булево> Если это установлено в значение true, то поток-работа будет отслеживать необработанные дескрипторы файлов, управляемые через fs.open() и fs.close(), и закрывать их при завершении потока-работы, подобно другим ресурсам, таким как сетевые сокеты или дескрипторы файлов, управляемые через API FileHandle. Этот параметр автоматически наследуется всеми вложенными Worker. По умолчанию: false.
  • transferList <массив объектов> Если один или несколько объектов типа MessagePort переданы в workerData, необходим transferList, в противном случае будет выброшено исключение ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. См. port.postMessage() для получения дополнительной информации.
  • resourceLimits <Объект> Необязательный набор ограничений ресурсов для нового экземпляра JS-движка. Достижение этих ограничений приведёт к завершению работы экземпляра Worker. Эти ограничения влияют только на JS-движок и не на внешние данные, в том числе не на ArrayBuffer. Даже если эти ограничения установлены, процесс может быть прерван, если он столкнётся с глобальной ситуацией недостатка памяти.
    • maxOldGenerationSizeMb <число> Максимальный размер основной кучи в МБ.
    • maxYoungGenerationSizeMb <число> Максимальный размер кучи пространства для недавно созданных объектов.
    • codeRangeSizeMb <число> Размер предварительно выделенного диапазона памяти, используемого для сгенерированного кода.
    • stackSizeMb <число> Максимальный размер стека по умолчанию для потока. Маленькие значения могут привести к непригодности экземпляров потоков-работы. По умолчанию: 4.

Событие: 'error'

• err <Ошибка>

Событие 'error' генерируется, если поток-работа выбросил необработанное исключение. В этом случае поток-работа будет завершён.

Событие: 'exit'

• exitCode <целое число>

Событие 'exit' генерируется, когда поток-работа останавливается. Если поток-работа завершился вызовом process.exit(), параметр exitCode будет содержать код завершения. Если поток-работа был завершён, параметр exitCode будет 1.

Это последнее событие, генерируемое экземпляром Worker.

Событие: 'message'

• value <любое> Переданное значение

Событие 'message' генерируется, когда поток-работа вызвал require('worker_threads').parentPort.postMessage(). Для получения дополнительной информации см. событие port.on('message').

Все сообщения, отправленные из потока-работы, будут сгенерированы до того, как будет сгенерировано событие 'exit' на объекте Worker.

Событие: 'messageerror'

• error <Ошибка> Объект Error

Событие 'messageerror' генерируется, когда десериализация сообщения завершилась неудачно.

Событие: 'online'

Событие 'online' генерируется, когда поток-работа начал выполнять код JavaScript.

worker.getHeapSnapshot()

• Возвращает: <Promise> Обещание для потока Readable, содержащего снимок кучи V8

Возвращает поток readable для снимка V8 текущего состояния Worker. Смотрите v8.getHeapSnapshot() для получения дополнительной информации.

Если поток Worker больше не работает, что может произойти до того, как будет выпущен 'exit' событие, возвращаемое Promise будет немедленно отклонено с ошибкой ERR_WORKER_NOT_RUNNING.

worker.performance

Объект, который можно использовать для запроса информации о производительности из экземпляра worker. Аналогично perf_hooks.performance.

performance.eventLoopUtilization([utilization1[, utilization2]])

• utilization1 <Объект> Результат предыдущего вызова eventLoopUtilization().
• utilization2 <Объект> Результат предыдущего вызова eventLoopUtilization() до utilization1.
• Возвращает <Объект>
  • idle <число>
  • active <число>
  • utilization <число>

Тот же вызов, что и perf_hooks eventLoopUtilization(), за исключением того, что возвращаются значения экземпляра worker.

Одно различие заключается в том, что, в отличие от основного потока, загрузка в worker выполняется в цикле событий. Поэтому использование цикла событий будет немедленно доступно после начала выполнения скрипта worker.

Время idle, которое не увеличивается, не указывает на то, что worker застрял в процессе инициализации. Следующие примеры показывают, как всё время существования worker не будет накапливаться время idle, но он всё ещё сможет обрабатывать сообщения.

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

if (isMainThread) {
  const worker = new Worker(__filename);
  setInterval(() => {
    worker.postMessage('hi');
    console.log(worker.performance.eventLoopUtilization());
  }, 100).unref();
  return;
}

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

Использование цикла событий worker доступно только после того, как будет выпущен 'online' событие, и если оно вызывается до этого или после 'exit' события, то все свойства имеют значение 0.

worker.postMessage(value[, transferList])

• value <любой>
• transferList <Массив объектов>

Отправить сообщение worker, которое будет получено через require('worker_threads').parentPort.on('message'). Смотрите port.postMessage() для получения дополнительной информации.

worker.ref()

Обратное unref(), вызов ref() для ранее unref() worker не позволит программе завершиться, если это единственная активная ссылка (по умолчанию). Если worker ref()ed, повторный вызов ref() не повлияет.

worker.resourceLimits

• <Объект>
  • maxYoungGenerationSizeMb <число>
  • maxOldGenerationSizeMb <число>
  • codeRangeSizeMb <число>
  • stackSizeMb <число>

Предоставляет набор ограничений ресурсов движка JS для этого потока Worker. Если опция resourceLimits была передана конструктору Worker, это соответствует её значениям.

Если worker остановлен, возвращаемое значение — пустой объект.

worker.stderr

• <stream.Readable>

Это поток readable, который содержит данные, записанные в process.stderr внутри потока worker. Если stderr: true не было передано в конструктор Worker, данные будут направлены в поток process.stderr родительского потока.

worker.stdin

• <null> | <stream.Writable>

Если stdin: true было передано в конструктор Worker, это поток writable. Данные, записанные в этот поток, будут доступны в потоке worker как process.stdin.

worker.stdout

• <stream.Readable>

Это поток readable, который содержит данные, записанные в process.stdout внутри потока worker. Если stdout: true не было передано в конструктор Worker, данные будут направлены в поток process.stdout родительского потока.

worker.terminate()

• Возвращает: <Promise>

Немедленно остановить все выполнение JavaScript в потоке worker. Возвращает Promise для кода выхода, который выполняется при выпуске 'exit' события.

worker.threadId

• <целое>

Целое идентификатор для ссылки на поток. Внутри потока worker он доступен как require('worker_threads').threadId. Это значение уникально для каждого экземпляра Worker внутри одного процесса.

worker.unref()

Вызов unref() для worker позволит потоку выйти, если это единственная активная ссылка в системе событий. Если worker уже unref()ed, повторный вызов unref() не повлияет.