Goroutines -
Awesome Go
Tools for managing and working with Goroutines.
- ants - A high-performance and low-cost goroutine pool in Go.
- artifex - Simple in-memory job queue for Golang using worker-based dispatching.
- async - An alternative sync library for Go (Future, Promise, Locks).
- async - A safe way to execute functions asynchronously, recovering them in case of panic.
- async-job - AsyncJob is an asynchronous queue job manager with light code, clear and speed.
- breaker - Flexible mechanism to make execution flow interruptible.
- channelify - Transform your function to return channels for easy and powerful parallel processing.
- conc - conc is your toolbelt for structured concurrency in go, making common tasks easier and safer.
- concurrency-limiter - Concurrency limiter with support for timeouts , dynamic priority and context cancellation of goroutines.
- conexec - 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.
- cyclicbarrier - CyclicBarrier for golang.
- execpool - 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.
- flowmatic - Structured concurrency made easy.
- go-accumulator - Solution for accumulation of events and their subsequent processing.
- go-actor - A tiny library for writing concurrent programs using actor model.
- go-floc - Orchestrate goroutines with ease.
- go-flow - Control goroutines execution order.
- go-tools/multithreading - Manage a pool of goroutines using this lightweight library with a simple API.
- go-trylock - TryLock support on read-write lock for Golang.
- go-waitgroup - Like sync.WaitGroup with error handling and concurrency control.
- go-workerpool - Inspired from Java Thread Pool, Go WorkerPool aims to control heavy Go Routines.
- go-workers - Easily and safely run workers for large data processing pipelines.
- goccm - Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently.
- gohive - A highly performant and easy to use Goroutine pool for Go.
- gollback - asynchronous simple function utilities, for managing execution of closures and callbacks.
- gowl - 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.
- goworker - goworker is a Go-based background worker.
- gowp - gowp is concurrency limiting goroutine pool.
- gpool - manages a resizeable pool of context-aware goroutines to bound concurrency.
- grpool - Lightweight Goroutine pool.
- hands - A process controller used to control the execution and return strategies of multiple goroutines.
- Hunch - Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.
- kyoo - Provides an unlimited job queue and concurrent worker pools.
- neilotoole/errgroup - Drop-in alternative to sync/errgroup, limited to a pool of N worker goroutines.
- nursery - Structured concurrency in Go.
- oversight - Oversight is a complete implementation of the Erlang supervision trees.
- parallel-fn - Run functions in parallel.
- pond - Minimalistic and High-performance goroutine worker pool written in Go.
- pool - Limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation.
- queue - Gives you a sync.WaitGroup like queue group accessibility. Helps you to throttle and limit goroutines, wait for the end of the all goroutines and much more.
- routine - 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.
- routine - go routine control with context, support: Main, Go, Pool and some useful Executors.
- semaphore - Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context.
- semaphore - Fast resizable semaphore implementation based on CAS (faster than channel-based semaphore implementations).
- stl - Software transactional locks based on Software Transactional Memory (STM) concurrency control mechanism.
- threadpool - Golang threadpool implementation.
- tunny - Goroutine pool for golang.
- worker-pool - goworker is a Go simple async worker pool.
- workerpool - Goroutine pool that limits the concurrency of task execution, not the number of tasks queued.
