node-threads-pool
Node-Threads-Pool
Node-Threads-Pool is a Node.js library that provides a simple and efficient way to execute tasks in child threads. It creates a pool of threads that can be used to parallelize the execution of CPU-intensive tasks, making it possible to take advantage of multi-core processors.
The library is designed to be easy to use and to integrate with existing projects. It provides a simple API that allows you to create a thread pool and run tasks in child threads, and it also supports passing data between threads.
Installation
You can install Node-Threads-Pool using NPM:
npm install node-threads-pool
Usage
To use Node-Threads-Pool, you need to create an instance of the Eve class, which represents the thread pool.
// main.js
const { Eve } = require('node-threads-pool');
const tp = new Eve(filename, threadCount);
The Eve constructor takes two arguments: the path to the worker script and the number of threads to create. The run method takes one argument, which is the data to be passed to the worker script.
filename: The path to the worker’s main script or module. See the Node.js documentation for more details.threadCount: The number of threads in the thread pool.
To run a task in a worker thread, use the run method:
// main.js
tp.run(workerData)
.then(result => {
// handle the result
})
.catch(err => {
// handle the error
})
When you no longer need the pool, call destroy() to immediately terminate all workers, reject any pending tasks, and release references so the instance can be garbage collected:
// main.js
tp.destroy();
You can create a new thread directly using the Thread class:
// thread.js
const {Thread} = require('node-threads-pool');
new Thread(async (data) => {
// Do some work with data
const result = await doSomething(data);
return result;
});
The Thread constructor takes a single argument, which is the function to be executed in the child thread. The function should return a Promise that resolves with the result of the computation.
Example
Here are some examples of how to use Node Threads Pool.
Example 1: Running calculations in 20 threads
This example shows how to create a pool of 20 worker threads to perform some calculations:
// main.js
const os = require('os');
const { Eve } = require('node-threads-pool');
const tp = new Eve('thread.js', os.cpus().length);
module.exports = async (data) => {
return await tp.run(data);
};
// thread.js
const { Thread } = require('node-threads-pool');
const thread = new Thread(async (data) => {
return await doSomething(data);
});
Alternatively, you can write to the same JS file:
// main.js
const { Eve, Thread, isMainThread } = require('node-threads-pool');
const os = require('os');
if(isMainThread) {
const tp = new Eve('thread.js', os.cpus().length);
module.exports = async (data) => {
return await tp.run(data);
};
} else {
new Thread(async (data) => {
return await doSomething(data);
});
}
Example 2: Rendering Pug to HTML
This example shows how to use Node Threads Pool to render Pug templates to HTML:
const pug = require('pug');
const os = require('os');
const {Eve, Thread, isMainThread} = require('node-threads-pool');
if(!isMainThread) {
const options = {};
new Thread(_data => {
const {template, data} = _data;
options.data = data;
return pug.renderFile(template, options);
});
} else {
const tp = new Eve(__filename, os.cpus().length);
module.exports = async (template, data) => {
return await tp.run({
template, data
});
};
}
Test
npm run eve
License
Node-Threads-Pool is licensed under the MIT License. (see LICENSE)