Goroutines

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

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

Orchestrate goroutines with ease

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)

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

A Future/Promise library with generic combinators and a DAG execution engine

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

Golang threadpool implementation

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

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

Minimalistic lifecycle orchestrator for Go components with dependency graphs, startup sequencing, readiness coordination, and graceful shutdown

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

An asynchronous task package with async/await style for Go

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

Library to manage component lifecycle in microservice architectures

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

Named FIFO mutexes with context cancellation, bounded wait queues, watchdog diagnostics, pprof profiles, and Prometheus metrics