src/worker/thread-worker.ts

   1 import {
   2   type MessagePort,
   3   isMainThread,
   4   parentPort,
   5   threadId
   6 } from 'node:worker_threads'
   7 import type { MessageValue } from '../utility-types.js'
   8 import { AbstractWorker } from './abstract-worker.js'
   9 import type { WorkerOptions } from './worker-options.js'
  10 import type { TaskFunction, TaskFunctions } from './task-functions.js'
  11
  12 /**
  13  * A thread worker used by a poolifier `ThreadPool`.
  14  *
  15  * When this worker is inactive for more than the given `maxInactiveTime`,
  16  * it will send a termination request to its main thread.
  17  *
  18  * If you use a `DynamicThreadPool` the extra workers that were created will be terminated,
  19  * but the minimum number of workers will be guaranteed.
  20  *
  21  * @typeParam Data - Type of data this worker receives from pool's execution. This can only be structured-cloneable data.
  22  * @typeParam Response - Type of response the worker sends back to the main thread. This can only be structured-cloneable data.
  23  * @author [Alessandro Pio Ardizio](https://github.com/pioardi)
  24  * @since 0.0.1
  25  */
  26 export class ThreadWorker<
  27   Data = unknown,
  28   Response = unknown
  29 > extends AbstractWorker<MessagePort, Data, Response> {
  30   /**
  31    * Message port used to communicate with the main worker.
  32    */
  33   private port?: MessagePort
  34
  35   /**
  36    * Constructs a new poolifier thread worker.
  37    *
  38    * @param taskFunctions - Task function(s) processed by the worker when the pool's `execution` function is invoked.
  39    * @param opts - Options for the worker.
  40    */
  41   public constructor (
  42     taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>,
  43     opts: WorkerOptions = {}
  44   ) {
  45     super(isMainThread, parentPort as MessagePort, taskFunctions, opts)
  46   }
  47
  48   /** @inheritDoc */
  49   protected handleReadyMessage (message: MessageValue<Data>): void {
  50     if (
  51       message.workerId === this.id &&
  52       message.ready === false &&
  53       message.port != null
  54     ) {
  55       try {
  56         this.port = message.port
  57         this.port.on('message', this.messageListener.bind(this))
  58         this.sendToMainWorker({
  59           ready: true,
  60           taskFunctionNames: this.listTaskFunctionNames()
  61         })
  62       } catch {
  63         this.sendToMainWorker({
  64           ready: false,
  65           taskFunctionNames: this.listTaskFunctionNames()
  66         })
  67       }
  68     }
  69   }
  70
  71   /** @inheritDoc */
  72   protected handleKillMessage (message: MessageValue<Data>): void {
  73     super.handleKillMessage(message)
  74     this.port?.unref()
  75     this.port?.close()
  76   }
  77
  78   /** @inheritDoc */
  79   protected get id (): number {
  80     return threadId
  81   }
  82
  83   /** @inheritDoc */
  84   protected readonly sendToMainWorker = (
  85     message: MessageValue<Response>
  86   ): void => {
  87     this.port?.postMessage({ ...message, workerId: this.id })
  88   }
  89
  90   /**
  91    * @inheritDoc
  92    * @override
  93    */
  94   protected handleError (error: Error | string): string {
  95     return error as string
  96   }
  97 }