Jeffail/tunny
Tunny
Tunny is a worker pool library and concurrency manager for Go. It functions as a concurrent task scheduler that limits the number of parallel workers processing jobs to prevent system resource exhaustion.
The project enables the maintenance of persistent state within individual worker routines to avoid repeated initialization costs. It also supports dynamic worker scaling, allowing the number of active background workers to be adjusted in real time without interrupting tasks in progress.
The library provides mechanisms for task timeout enforcement and worker lifecycle management, including the graceful shutdown of routine pools. It utilizes concurrency limiting to restrict the total number of active goroutines.
Features
- Concurrent Task Execution - Provides a system for executing multiple Go routines in parallel while limiting active workers.
- Persistent Worker State - Enables individual worker routines to maintain local state across multiple task executions for optimization.
- Dynamic Scaling - Supports real-time adjustment of the number of active background workers based on demand.
- Worker Pool Management - Offers a library for managing worker pool concurrency, lifecycles, and internal state.
- Dynamic Pool Scalings - Allows adjusting the number of active worker goroutines at runtime without interrupting tasks.
- Goroutine Lifecycle Management - Manages the lifecycle and scaling of worker pools in Go to optimize performance and memory usage.
- Goroutine Pools - Provides lightweight goroutine pools for managing high-volume task execution in Go.
- Worker Lifecycle Management - Provides capabilities for starting, stopping, and dynamically scaling background worker processes.
- Concurrent Task Schedulers - Functions as a scheduler that manages active concurrent operations with enforced timeouts and resource limits.
- Context-Aware Cancellation - Uses Go contexts to propagate cancellation signals and enforce timeouts for running worker routines.
- Channel-Based Workers - Implements worker pools that use Go channels to distribute tasks and manage concurrency.
- Job Timeout Enforcements - Implements mechanisms to automatically abort jobs that exceed a specified maximum run time.
- Routine Pool Shutdowns - Provides lifecycle management for the graceful startup and shutdown of worker routine pools.
- Concurrency Semaphores - Uses semaphore-based primitives to restrict the total number of active goroutines and prevent resource exhaustion.
- Concurrent Execution Limiters - Constrains the number of simultaneously active asynchronous tasks to prevent system resource exhaustion.
- Task Scheduling and Queues - Goroutine pool library.
- Concurrency Management - Goroutine pool implementation.
- Concurrency Tools - Listed in the “Concurrency Tools” section of the Awesome Go awesome list.
