Goroutines

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

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

An asynchronous task package with async/await style for Go

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

A safe way to execute functions asynchronously, recovering them in case of panic

AsyncJob is an asynchronous queue job manager with light code, clear and speed

Flexible mechanism to make execution flow interruptible

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

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

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

Orchestrate goroutines with ease

Control goroutines execution order

A highly performant and easy to use Goroutine pool for Go

asynchronous simple function utilities, for managing execution of closures and callbacks

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 is a Go-based background worker

gowp is concurrency limiting goroutine pool

manages a resizeable pool of context-aware goroutines to bound concurrency

Lightweight Goroutine pool

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

Hunch provides functions like: `All`, `First`, `Retry`, `Waterfall` etc., that makes asynchronous flow control more intuitive

Provides an unlimited job queue and concurrent worker pools

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

Structured concurrency in Go

Run functions in parallel

Minimalistic and High-performance goroutine worker pool written in Go

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

Go toolkit for clean, composable, channel-based concurrency

`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

go routine control with context, support: Main, Go, Pool and some useful Executors

Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context

Library to manage component lifecycle in microservice architectures

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

CyclicBarrier for golang

Structured concurrency made easy

Solution for accumulation of events and their subsequent processing

A tiny library for writing concurrent programs using actor model

Manage a pool of goroutines using this lightweight library with a simple API

TryLock support on read-write lock for Golang

Like `sync.WaitGroup` with error handling and concurrency control

Inspired from Java Thread Pool, Go WorkerPool aims to control heavy Go Routines

Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently

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

Software transactional locks based on Software Transactional Memory (STM) concurrency control mechanism

Golang threadpool implementation

Goroutine pool for golang

goworker is a Go simple async worker pool

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

Zero-config, auto-scaling worker pool for Go with priority-aware scheduling