# Node Thread Pool :arrow_double_up: :on:
[](https://standardjs.com)
[](https://badgen.net/dependabot/dependabot/dependabot-core/?icon=dependabot)
[](https://github.com/pioardi/node-pool/actions)
Contents
Overview
Node pool contains two worker-threads pool implementations , you don' t have to deal with worker-threads complexity.
The first implementation is a static thread pool , with a defined number of threads that are started at creation time .
The second implementation is a dynamic thread pool with a number of threads started at creation time and other threads created when the load will increase ( with an upper limit ), the new created threads will be stopped after a threshold.
You have to implement your worker extending the ThreadWorker class
Installation
```
npm install node-thread-pool --save
```
Usage
You can implement a worker in a simple way , extending the class ThreadWorker :
```js
'use strict'
const { ThreadWorker } = require('node-pool')
class MyWorker extends ThreadWorker {
constructor () {
super((data) => {
// this will be executed in the worker thread,
// the data will be received by using the execute method
return { ok: 1 }
}, { maxInactiveTime: 1000 * 60})
}
}
module.exports = new MyWorker()
```
Instantiate your pool based on your needed :
```js
'use strict'
const { FixedThreadPool, DynamicThreadPool } = require('node-pool')
// a fixed thread pool
const pool = new FixedThreadPool(15,
'./yourWorker.js')
// or a dynamic thread pool
const pool = new DynamicThreadPool(10, 100,
'./yourWorker.js')
pool.emitter.on('FullPool', () => console.log('Pool is full'))
// the execute method signature is the same for both implementations,
// so you can easy switch from one to another
pool.execute({}).then(res => {
console.log(res)
}).catch ....
```
See examples folder for more details.
Node versions
You can use node version 10.x with --experimental-worker flag, or you can use an higher version (i.e 12.x)
API
### `pool = new FixedThreadPool(numThreads, filePath, opts)`
`numThreads` (mandatory) Num of threads for this worker pool
`filePath` (mandatory) Path to a file with a worker implementation
`opts` (optional) An object with these properties :
- `errorHandler` - A function that will listen for error event on each worker thread
- `onlineHandler` - A function that will listen for online event on each worker thread
- `exitHandler` - A function that will listen for exit event on each worker thread
- `maxTasks` - This is just to avoid not useful warnings message, is used to set maxListeners on event emitters ( workers are event emitters)
### `pool = new DynamicThreadPool(min, max, filePath, opts)`
`min` (mandatory) Same as FixedThreadPool numThreads , this number of threads will be always active
`max` (mandatory) Max number of workers that this pool can contain, the new created threads will die after a threshold ( default is 1 minute , you can override it in your worker implementation).
`filePath` (mandatory) Same as FixedThreadPool
`opts` (optional) Same as FixedThreadPool
### `pool.execute(data)`
Execute method is available on both pool implementations ( return type : Promise):
`data` (mandatory) An object that you want to pass to your worker implementation
### `pool.destroy()`
Destroy method is available on both pool implementations.
This method will call the terminate method on each worker.
### `class YourWorker extends ThreadWorker`
`fn` (mandatory) The function that you want to execute on the worker thread
`opts` (optional) An object with these properties :
- `maxInactiveTime` - Max time to wait tasks to work on ( in ms) , after this period the new worker threads will die.
Contribute
See guidelines [CONTRIBUTING](./.github/CONTRIBUTING.md)
License
[MIT](https://github.com/pioardi/node-pool/blob/master/LICENSE)