Filter By
70 Resources
Golang Goroutines
Queue is a Golang library for spawning and managing a Goroutine pool
Queue is a Golang library for spawning and managing a Goroutine pool, Alloowing you to create multiple worker according to limit CPU number of machine.
This repository collects common concurrency patterns in Golang
Go Concurrency Patterns This repository collects common concurrency patterns in Golang Materials Concurrency is not parallelism Go Concurrency Pattern
goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.
goworker goworker is a Resque-compatible, Go-based background worker. It allows you to push jobs into a queue using an expressive language like Ruby w
Reactive Extensions for the Go language.
RxGo Reactive Extensions for the Go Language ReactiveX ReactiveX, or Rx for short, is an API for programming with Observable streams. This is the offi
🐜🐜🐜 ants is a high-performance and low-cost goroutine pool in Go, inspired by fasthttp./ ants 是一个高性能且低损耗的 goroutine 池。
A goroutine pool for Go English | 🇨🇳 中文 📖 Introduction Library ants implements a goroutine pool with fixed capacity, managing and recycling a massi
Queue is a Golang library for spawning and managing a Goroutine pool
Queue is a Golang library for spawning and managing a Goroutine pool, Alloowing you to create multiple worker according to limit CPU number of machine.
Routine - ThreadLocal for golang
routine 中文版 routine encapsulates and provides some easy-to-use, high-performance
:speedboat: a limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation
Package pool Package pool implements a limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation. Features
A sync.WaitGroup with error handling and concurrency control
go-waitgroup How to use An package that allows you to use the constructs of a sync.WaitGroup to create a pool of goroutines and control the concurrenc
A goroutine pool for Go
Tunny is a Golang library for spawning and managing a goroutine pool, allowing you to limit work coming from any number of goroutines with a synchrono
Provides some convenient API, includes Goid(), AllGoid(), and LocalStorage, which is a goroutine's local storage, just like ThreadLocal in other languages.
routine 中文版 routine encapsulates and provides some easy-to-use, high-performance goroutine context access interfaces, which can help you access corout
Go asynchronous simple function utilities, for managing execution of closures and callbacks
⚙️ gollback gollback - Go asynchronous simple function utilities, for managing execution of closures and callbacks 📖 ABOUT Contributors: Rafał Lorenz
Batch processing library for Go supports generics & values returning
Aggregator Aggregator is a batch processing library for Go supports returning values. You can group up and process batch of tasks with keys in a singl
A universal mechanism to manage goroutine lifecycles
A universal mechanism to manage goroutine lifecycles
Concurrency limiting goroutine pool
workerpool Concurrency limiting goroutine pool. Limits the concurrency of task execution, not the number of tasks queued. Never blocks submitting task
Structured Concurrency in Go
nursery: structured concurrency in Go RunConcurrently( // Job 1 func(context.Context, chan error) { time.Sleep(time.Millisecond * 10)
Goroutine Leak Detector
Leaktest Refactored, tested variant of the goroutine leak detector found in both net/http tests and the cockroachdb source tree. Takes a snapshot of r
Simple in-memory job queue for Golang using worker-based dispatching
artifex Simple in-memory job queue for Golang using worker-based dispatching Documentation here: https://godoc.org/github.com/mborders/artifex Cron jo
Alternative sync library for Go
Alternative sync library for Go. Overview Future - A placeholder object for a value that may not yet exist. Promise - While futures are defined as a t
Minimalistic and High-performance goroutine worker pool written in Go
pond Minimalistic and High-performance goroutine worker pool written in Go Motivation This library is meant to provide a simple way to limit concurren
Unlimited job queue for go, using a pool of concurrent workers processing the job queue entries
kyoo: A Go library providing an unlimited job queue and concurrent worker pools About kyoo is the phonetic transcription of the word queue. It provide
A safe way to execute functions asynchronously, recovering them in case of panic. It also provides an error stack aiming to facilitate fail causes discovery.
Async Provides a safe way to execute functions asynchronously, recovering them in case of panic. It also provides an error stack aiming to facilitate
golang worker pool , Concurrency limiting goroutine pool
golang worker pool 中文说明 Concurrency limiting goroutine pool. Limits the concurrency of task execution, not the number of tasks queued. Never blocks su
Go-ldap-pool - A simple connection pool for go-ldap
Basic connection pool for go-ldap This little library use the go-ldap library an
errgroup with goroutine worker limits
neilotoole/errgroup neilotoole/errgroup is a drop-in alternative to Go's wonderful sync/errgroup but limited to N goroutines. This is useful for inter
Fast resizable golang semaphore primitive
semaphore Fast resizable golang semaphore based on CAS allows weighted acquire/release; supports cancellation via context; allows change semaphore lim
🚧 Flexible mechanism to make execution flow interruptible.
🚧 breaker Flexible mechanism to make execution flow interruptible. 💡 Idea The breaker carries a cancellation signal to interrupt an action execution
Golang simple thread pool implementation
Golang Threadpool implementation Scalable threadpool implementation using Go to handle the huge network trafic. Install go get github.com/shettyh/thre
Limits the number of goroutines that are allowed to run concurrently
Golang Concurrency Manager Golang Concurrency Manager package limits the number of goroutines that are allowed to run concurrently. Installation Run t
Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive.
Hunch Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive. About Hunch Go have sever
Floc: Orchestrate goroutines with ease.
go-floc Floc: Orchestrate goroutines with ease. The goal of the project is to make the process of running goroutines in parallel and synchronizing the
Simply way to control goroutines execution order based on dependencies
Goflow Goflow is a simply package to control goroutines execution order based on dependencies. It works similar to async.auto from node.js async packa
🚦 Semaphore pattern implementation with timeout of lock/unlock operations.
🚦 semaphore Semaphore pattern implementation with timeout of lock/unlock operations. 💡 Idea The semaphore provides API to control access to a shared
go routine control, abstraction of the Main and some useful Executors.如果你不会管理Goroutine的话，用它
routine Routine Architecture Quick Start package main import ( "log" "context" "github.com/x-mod/routine" ) func main(){ if err := routine.Main
Lightweight Goroutine pool
grpool Lightweight Goroutine pool Clients can submit jobs. Dispatcher takes job, and sends it to first available worker. When worker is done with proc
Off heap golang memory pool
Stealthpool stealthpool provides a memory pool that allocates blocks off-heap that will NOT be tracked by the garbage collector. The name stealthpool
👷 Library for safely running groups of workers concurrently or consecutively that require input and output through channels
Examples Quickstart Multiple Go Workers Passing Fields Getting Started Pull in the dependency go get github.com/catmullet/go-workers Add the import to
CyclicBarrier golang implementation
cyclicbarrier CyclicBarrier is a synchronizer that allows a set of goroutines to wait for each other to reach a common execution point, also called a
Software Transactional Locks
Software Transactional Locks Package stl provides multiple atomic dynamic shared/exclusive locks, based on Software Transactional Memory (STM) concurr
Run tasks concurrently with limits
Workerpool Package workerpool implements a concurrency limiting worker pool. Worker routines are spawned on demand as tasks are submitted. This packag
gpool - a generic context-aware resizable goroutines pool to bound concurrency based on semaphore.
gpool - a generic context-aware resizable goroutines pool to bound concurrency. Installation $ go get github.com/sherifabdlnaby/gpool import "github.c
A lib for monitoring runtime goroutine stack
Overview A lib for monitoring runtime goroutine stack. Such as wait for goroutines to exit, leak detection, etc. Features context.Context first design
generic sync.Pool
syncpool The mkm.pub/syncpool package provides a generic wrapper around the sync.Pool structure. This package is just a thin wrapper around the underl
Worker pool library with auto-scaling, backpressure, and easy composability of pools into pipelines
workerpool Worker pool library with auto-scaling, backpressure, and easy composability of pools into pipelines. Uses Go 1.18 generics. Notable differe
Go simple async worker pool
👨🔧 worker-pool Go simple async worker pool. 📖 ABOUT Worker pool is a software design pattern for achieving concurrency of task execution. Maintain
Run functions in parallel :comet:
Parallel fn Run functions in parallel. Limit the number of goroutines running at the same time. Installation go get -u github.com/rafaeljesus/parallel
🐝 A Highly Performant and easy to use goroutine pool for Go
gohive Package gohive implements a simple and easy to use goroutine pool for Go Features Pool can be created with a specific size as per the requireme
TryLock support on read-write lock for Golang
go-trylock TryLock support on read-write lock for Golang Interface go-trylock implements sync.Locker. Have same interfaces with sync.RWMutex Documenta
Set up tasks to be executed in parallel.
A simple Go library to set up tasks to be executed in parallel. package main import ( "context" "log" "github.com/bep/workers" ) func main() {
高性能go协程池，代码清晰易懂
gowp 高性能go协程池，代码清晰易懂 安装 go get github.com/linzhepeng/gowp 为什么要用协程池 go的协程虽然轻量级，单个goroutine只有2KB，但毫无止境地使用也会占据大量的系统资源，导致调度性能下降、GC 频繁、内存暴涨, 引发一系列问题。 可以测试如
Go-async - Worker pool (fan-in/fan-out)
Worker pool (fan-in/fan-out) func main() { pool := worker.NewPool(2) ctx := co
Golang Implementation of Worker Pool/ Thread Pool
Golang Implementation of Worker Pool/ Thread Pool
Worker-Pool written in GO
go-workerpool Worker-Pool written in GO Installation go get github.com/agungsid/go-workerpool Usage package main type SampleSeeder struct{} func (s