andywer/threads.js
Threads.js
threads.js is a JavaScript worker thread library and asynchronous task orchestrator designed to offload CPU-intensive tasks to background threads. It functions as a cross-platform worker pool and a TypeScript worker runner that automatically transpiles and executes TypeScript files within separate threads.
The project distinguishes itself by providing a unified worker API that allows for cross-platform execution across different JavaScript environments. It includes a specialized worker data serialization tool to pass complex class instances and binary data between threads, and supports inlining worker source code as binary blobs.
The library covers a broad range of capabilities including thread pool management, concurrency control, and task cancellation. It also provides mechanisms for binary data transfer via memory buffers, worker error propagation with stack traces, and code sandboxing for isolating security-critical logic.
Features
- JavaScript Multi-Threading - Implements an execution model that enables multi-threaded operation for JavaScript engines to bypass the event loop.
- Node.js Worker Thread Pools - Maintains a queue of tasks and a fixed set of workers to balance CPU load and resource consumption.
- Complex Data Serialization - Supports registering custom serializers to pass class instances and non-cloneable data types between threads.
- Blocking Task Offloaders - Executes CPU intensive tasks in background threads to prevent blocking the main thread.
- TypeScript Transpilers - Automatically compiles TypeScript source files into JavaScript at runtime before spawning worker threads.
- Cross-Platform Worker APIs - Provides a unified worker API that allows for cross-platform execution across different JavaScript environments.
- Thread Pools - Manages a controlled group of worker threads to distribute bulk tasks and prevent system resource exhaustion.
- General Purpose - Organizes bulk task executions using thread pools to optimize resource usage and increase overall throughput.
- TypeScript Execution - Enables running TypeScript files in worker threads by automatically transpiling the code during execution.
- Background Thread Integration - Executes TypeScript logic in worker threads with automatic transpilation and seamless promise-based communication.
- Asynchronous Worker Functions - Allows defining functions within worker threads to handle asynchronous calls originating from the main execution thread.
- Message-to-Promise Proxies - Wraps worker postMessage calls in promises to allow asynchronous function calls between the main thread and workers.
- Asynchronous Task Orchestrators - Functions as a system for queuing and managing asynchronous jobs with support for task cancellation and concurrency control.
- Background Thread Dispatchers - Runs functions in separate threads and proxies the return values back to the main thread to maintain responsiveness.
- Concurrent Task Limiters - Limits the number of concurrent worker threads to prevent system resource exhaustion during CPU-intensive tasks.
- Unified Worker APIs - Provides a consistent interface for spawning and communicating with workers across multiple JavaScript environments.
- Complex Object Serializers - Translates complex class instances into cloneable formats to bypass the limitations of the structured clone algorithm.
- Pending Task Cancellations - Provides the ability to remove pending tasks from the execution queue before they are picked up by a worker thread.
- Worker Lifecycle Management - Manages the creation and termination of worker threads to optimize resource usage.
- Distributed Task Workers - Assigns bulk tasks across a controlled group of workers to process high-volume workloads in a predictable manner.
- Worker Source Inlining - Converts worker source code into binary blob URLs to execute background logic without requiring separate physical files.
- Inter-Thread Data Transfers - Moves ownership of ArrayBuffers between threads to avoid expensive data copying for large binary datasets.
- JavaScript Runtime Compatibility Layers - Provides a consistent interface to wrap platform-specific worker implementations for compatibility across different JavaScript environments.
- JavaScript Runtime Portability - Allows running worker thread logic across different JavaScript environments without modifying the source code.
- Worker Thread Runners - Automatically transpiles and executes TypeScript files within separate worker threads.
- Worker Process Error Reporting - Forwards errors from a worker thread to the main thread's promise chain including the original stack trace.
- Observable Streams - Uses a push-based stream of events to transmit continuous updates from a background thread to the main thread.
- Task Completion Tracking - Tracks the progress of all queued tasks and resolves only after every job has finished or failed.
- Reactive Worker Streams - Implements a push-based stream using observables to transmit continuous updates from worker threads to the main thread.
- Web Worker Management - Uniform API for worker threads.
