A high-performance and low-cost goroutine pool in Go.

conc is your toolbelt for structured concurrency in go, making common tasks easier and safer.

Goroutine pool for golang.

goworker is a Go-based background worker.

Minimalistic and High-performance goroutine worker pool written in Go.

Go toolkit for clean, composable, channel-based concurrency.

Goroutine pool that limits the concurrency of task execution, not the number of tasks queued.

Lightweight Goroutine pool.

Limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation.

gowp is concurrency limiting goroutine pool.

Structured concurrency made easy.

Orchestrate goroutines with ease.

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.

An alternative sync library for Go (Future, Promise, Locks).

Control goroutines execution order.

Simple in-memory job queue for Golang using worker-based dispatching.

Fast resizable semaphore implementation based on CAS (faster than channel-based semaphore implementations).

A tiny library for writing concurrent programs using actor model.

Easily and safely run workers for large data processing pipelines.

Drop-in alternative to sync/errgroup, limited to a pool of N worker goroutines.

CyclicBarrier for golang.

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.

Golang threadpool implementation.

goworker is a Go simple async worker pool.

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.

Structured concurrency in Go.

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.

Run functions in parallel.

TryLock support on read-write lock for Golang.

Transform your function to return channels for easy and powerful parallel processing.

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.

A process controller used to control the execution and return strategies of multiple goroutines.

An asynchronous task package with async/await style for Go.

Solution for accumulation of events and their subsequent processing.