-
anchor - Library to manage component lifecycle in microservice architectures.
-
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 asynchronous task package with async/await style for Go.
-
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.
-
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.
-
rill - Go toolkit for clean, composable, channel-based concurrency.
-
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.
← All categories