thread_pools

Thread pool with Auto-configuration for worker_threads, provides both thread and pool function, has thread-safe storage

Usage

Use --experimental-worker flag while running the code.

const Pool = require("thread_pools");
 
let ezpool = new Pool();
let pool = new Pool({
  threads: 2,
  importGlobal: `const os = require('os');`,
  waitMs: 1000,
});
 
for (let i = 0; i < 10; i++) {
  pool.threadPool((index) => console.log(os.cpus().length + index), i);
}
 
pool
  .threadSingle(() => {
    process.env.returnType = "String";
  })
  .then(() => console.log(process.env.returnType));
 
pool.threadSingleStoppable(() => {}).cancel();

features

1. Auto configured

2. Lazy initialize threads in thread pool

3. can use console.log inside thread function

4. has thread-safe storage, can pass javascript Object

Notice

• better initialize Pool only once and Store it in a global variable

• some libraries are unable to support worker_threads, like bcrypt

• process.env is thread unsafe, use with caution.

• thread-safe storage is very expensive

• func cannot use any pre-declared variable, need to pass in as a parameter

let variable = 10;
pool.threadSingle(() => console.log(variable)); // not gonna work, out of scope
pool.threadSingle((v) => console.log(v), variable); // 10

API

Pool(options)

{
    threads = if No. of cpu < 3, then 2, else (cpu No. * 2 - 2)
    importGlobal : import / require statement for every threads
    waitMs: Main Thread Pool Checker, wait certain time until pools freed up
}

---

async threadSingle(func, ...param)

func : toStringable / cloneable function, param : parameters of func

single thread runner, very expensive, auto closed.

---

async threadSingleStoppable(func, ...param)

return {cancel:Function, result:Promise} also auto closed after finish

---

async threadPool(func, ...param)

func : toStringable / cloneable function, param : parameters of func

use already initialized threads, expensive at the beginning but much faster than threadSingle for larger task

---

async threadPoolStoppable(func, ...param)

return Promise<{cancel:Function,uid:Number, result:Promise}>

threadPoolStoppable().catch() will not catch the error, use

threadPoolStoppable().then(data=>data.result.catch()) instead

every time you call it, it will generate a unique uid, can use it to call _threadPoolStop

when thread returned a result, it will not be cancelled / terminated, but you can still call it;

---

async _threadPoolStop(uid = 0)

if(uid > 0) cancel corresponding thread, has no effect on already finished thread

if(uid == 0) delete all threads in thread pool

if(uid < 0) no effect

---

Inner API

usage

const assist = require("thread_pools").assist;

assist is a keyword, so you have to use this one.

inner api is the function you can use within func

i.e.

threadSingle(() => assist.sleep(2)).then(() => {}); // wait 2 seconds

---

async assist.sleep(seconds)

resolve after certain seconds

---

assist.serialize(object)

use eval('('+object+')') to deserialize

---

async assist.lock()

try to manually acquire the main lock, will wait until the lock is lifted

---

async assist.unlock()

better call assist.lock() beforehand, other threads may have access to the shared data

---

async assist.waitComplete(callback)

wait for the return of the event queue (wait until main thread worker's event queue's callback)

---

async assist.autoLocker(callback)

acquire the lock, call assist.waitComplete, and finally release the lock after callback finshed

---

async assist.storage(callback = (store = {}) => {})

thread-safe & synced storage, can communicate between different threads, can be used by both single and pool, any change on the store will reflecte on the original pool.storage

pool.storage.p = 0;
pool.threadSingle(() => assist.storage((item) => item.p++)).then(() => console.log(pool.storage));

storage will aquire lock first, then copy main thread storage, wait until user callback finish, update main thread storage, remove lock, and return updated value