https://github.com/hellivan/node-task-scheduling-utilities
Node.js task scheduling utilities
https://github.com/hellivan/node-task-scheduling-utilities
nodejs observable parallel pool pooling scheduling task thread thread-pool typescript utils worker worker-threads
Last synced: about 1 month ago
JSON representation
Node.js task scheduling utilities
- Host: GitHub
- URL: https://github.com/hellivan/node-task-scheduling-utilities
- Owner: hellivan
- License: mit
- Created: 2020-03-22T21:01:01.000Z (about 6 years ago)
- Default Branch: develop
- Last Pushed: 2023-11-13T18:52:51.000Z (over 2 years ago)
- Last Synced: 2025-09-19T03:59:49.721Z (9 months ago)
- Topics: nodejs, observable, parallel, pool, pooling, scheduling, task, thread, thread-pool, typescript, utils, worker, worker-threads
- Language: TypeScript
- Homepage:
- Size: 125 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 13
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# ntsu - Node.js task scheduling utilities
[](https://circleci.com/gh/hellivan/node-task-scheduling-utilities)
[](https://codecov.io/gh/hellivan/node-task-scheduling-utilities)
[](LICENSE)
[](https://github.com/semantic-release/semantic-release)
[](https://renovatebot.com/)
[](https://www.npmjs.com/package/ntsu)
[](https://www.npmjs.com/package/ntsu)
Utility library that provides some basic mechanisms for task scheduling/execution in Node.js
## Installation
Using npm:
```
npm install --save ntsu
```
Using yarn
```
yarn add ntsu
```
## Usage
In ES6 / Typescript
```typescript
import { DynamicWorkerPool, QdScheduler, WorkerThreadWorker } from 'ntsu';
```
### QdScheduler
Queued task scheduler that executes provided tasks one after another or in parallel, depending on the provided
configuration. Tasks that cannot be executed immediately are queued for later execution. Queued tasks are executed as
soon as running tasks complete:
```typescript
import { QdScheduler } from 'ntsu';
// create new queued scheduler that can execute 3 tasks in parallel
// and is able to queue up to 100 tasks
const scheduler = new QdScheduler(3, 100);
for (let i = 0; i < 100; i++) {
scheduler.queueTask({ exec: () => complexFunction(i) });
}
scheduler.start();
```
### DynamicWorkerPool
Generic worker pool that dynamically instantiates new workers as needed. Initially the pool
will be empty. When tasks are added for execution, the pool will create up to maxSize new workers
that will execute the given tasks. After task execution, all superfluous workers are disposed after a given
worker-idle timeout so that only minSize workers will remain in the pool. These workers are then reused in
future task executions.
```typescript
import { DynamicWorkerPool } from 'ntsu';
// create new dynamic worker pool that uses workerFactory to instantiate new workers
// and has a max size of 10. The pool will keep at least 3 idle workers. Workers are
// considered idle if no task is assigned withing 3 seconds
const pool = new DynamicWorkerPool(workerFactory, 3, 10, 3000);
const results = Promise.all(tasks.map((task) => scheduler.executeTask(task)));
```
### WorkerThreadWorker
WorkerPool worker implementation that is based on node.js `worker_threads`. This Worker implementation
will automatically create a new `worker_thread` based on the given script path and post the task's data
via `postMessage` method. Worker threads will be instantiated in a lazy way (as soon as `executeTask` is
called for the first time). If `worker_thread` fails or exits before emitting a repsonse message via `postMessage`
method, result-promise of `executeTask` will reject with an appropriate error message. `worker_thread`
termination or failure between task-execution will also be catched by this implemenation. If `worker_thread`
errors or terminates a new `worker_thread` will be instantiated upon next task execution.
```typescript
import { WorkerThreadWorker } from 'ntsu';
// create a workerfactory that instantiates new WorkerThreadWorker workers, that
// use workerThreadScript.js as worker_threads script
const workerFactory = {
createWorker: () => new WorkerThreadWorker('workerThreadScript.js')
);
```
Where an example `worker_thread` script could be:
```js
// workerThreadScript.js
const { parentPort } = require('worker_threads');
parentPort.on('message', (message) => {
parentPort.postMessage(`Hello "${message}"!`);
});
```