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