Goroutines Go Libraries Ranking
Tools for managing and working with Goroutines.
51 repositories, updated daily.
- `conc` is your toolbelt for structured concurrency in go, making common tasks easier and safer.
- Minimalistic and High-performance goroutine worker pool written in Go.
- Goroutine pool that limits the concurrency of task execution, not the number of tasks queued.
- Limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation.
reugn/async
- An alternative sync library for Go (Future, Promise, Locks).
- A tiny library for writing concurrent programs using actor model.
- `routine` is a `ThreadLocal` for go library. It encapsulates and provides some easy-to-use, non-competitive, high-performance `goroutine` context access interfaces, which can help you access coroutine context information more gracefully.
- Simple in-memory job queue for Golang using worker-based dispatching.
- Fast resizable semaphore implementation based on CAS (faster than channel-based semaphore implementations).
- Drop-in alternative to `sync/errgroup`, limited to a pool of N worker goroutines.
- A safe way to execute functions asynchronously, recovering them in case of panic.
- asynchronous simple function utilities, for managing execution of closures and callbacks.
- Hunch provides functions like: `All`, `First`, `Retry`, `Waterfall` etc., that makes asynchronous flow control more intuitive.
- Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context.
- manages a resizeable pool of context-aware goroutines to bound concurrency.
- Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently.
- Gowl is a process management and process monitoring tool at once. An infinite worker pool gives you the ability to control the pool and processes and monitor their status.
- go routine control with context, support: Main, Go, Pool and some useful Executors.
- A highly performant and easy to use Goroutine pool for Go.
- Provides an unlimited job queue and concurrent worker pools.
- Like `sync.WaitGroup` with error handling and concurrency control.
- Transform your function to return channels for easy and powerful parallel processing.
ssgreg/stl
- Software transactional locks based on Software Transactional Memory (STM) concurrency control mechanism.
- A pool built around exec.Cmd that spins up a given number of processes in advance and attaches stdin and stdout to them when needed. Very similar to FastCGI or Apache Prefork MPM but works for any command.
- Flexible mechanism to make execution flow interruptible.
- Concurrency limiter with support for timeouts, dynamic priority and context cancellation of goroutines.
- A concurrent toolkit to help execute funcs concurrently in an efficient and safe way. It supports specifying the overall timeout to avoid blocking and uses goroutine pool to improve efficiency.
- Manage a pool of goroutines using this lightweight library with a simple API.
- Inspired from Java Thread Pool, Go WorkerPool aims to control heavy Go Routines.
- AsyncJob is an asynchronous queue job manager with light code, clear and speed.
- Solution for accumulation of events and their subsequent processing.
- A process controller used to control the execution and return strategies of multiple goroutines.
- Zero-config, auto-scaling worker pool for Go with priority-aware scheduling.
kyuff/anchor
- Library to manage component lifecycle in microservice architectures.
- Named FIFO mutexes with context cancellation, bounded wait queues, watchdog diagnostics, pprof profiles, and Prometheus metrics.