microjob VS threads.js

node.js is multithreaded under the hood and always has been. It's true that we used to not have multi thread capability as developers, but we actually have for several years now, but most developers have probably never used it. Even prior to Worker Threads/Shared Buffers, we had 3rd party modules such as node-fiber and various shared memory data structure libraries which could be used to build multi threaded javascript programs. https://github.com/wilk/microjob <- dead simple batteries included multi threading in node.js

Real life example: We wanted our website to be static files to save on system time as a kind of caching strategy. So far there are about 100 pages that need to be rendered sometimes when there is an update to the site. Running all of this through our templating engine at once caused the node server to be unresponsive for about 30 to 40 seconds. No joy. There are a few ways to solve this but the one we decided on was to use web worker threads for this execution because this was not going to happen very often. About 5% to 10% of the time. It basically just puts this function (rendering all of the pages) into another thread and returns the result. Now this takes about 15 to 20 seconds and does not hold up the main thread. We used a library called Microjob that makes using a web worker really easy https://github.com/wilk/microjob

Threads.js makes it pretty easy to spawn a thread pool and handle multi-threading workloads.

We did this via the npm threads wrapper and esbuild. We first moved all of our compute code into a new file with minimal imports, called imageCompare.worker.js. We then added a pre-compilation step with esbuild to compile this file into a bundle. We then spawn the worker using this generated file as a blob, and interact with it via the threads promise interface.

That latter one is in it's own process, and I also use multiple threads with the threads library.

This app has a memory leak where your worker threads are spawning out of control. You can verify this in Chrome DevTools Source tab: after you click the Generate button, you can see the worker threads spawning out of control until you close the process.

I'd advise that you do a better job at manually spawning and terminating the threads with the TFJS process. I've had success using this library in combination with TFJS: https://threads.js.org/

You can use it for everything. Even the compute tasks you can offload to worker threads using something like https://github.com/andywer/threads.js or you could create intensive modules in Rust and integrate using something like https://github.com/neon-bindings/neon

Web worker meets worker threads – threads.js\ (3 comments)

threads.js