Filter By
67 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.
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
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
๐๐๐ 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
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
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
A universal mechanism to manage goroutine lifecycles
A universal mechanism to manage goroutine lifecycles
๐ฆ 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
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
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
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
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
: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
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
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
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
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
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
Routine - ThreadLocal for golang
routine ไธญๆ็ routine encapsulates and provides some easy-to-use, high-performance
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
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
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.
Goworkers - Zero dependency Golang worker pool
Golang Worker Pool Zero dependency golang goroutines pool library. It is useful
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
Structured Concurrency in Go
nursery: structured concurrency in Go RunConcurrently( // Job 1 func(context.Context, chan error) { time.Sleep(time.Millisecond * 10)
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
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
Go-miningcore-pool - Miningcore Pool written in GOlang
Go-Miningcore-Pool (COMING SOON) Miningcore Pool written in GOlang 0x01 Configur
๐ท 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
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
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
Worker - A Golang library that provides worker pools
Worker A Golang library that provides worker pools. Usage See *_test.go files. T
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
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 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
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
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
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
๐ง 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
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
Software Transactional Locks
Software Transactional Locks Package stl provides multiple atomic dynamic shared/exclusive locks, based on Software Transactional Memory (STM) concurr
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
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() {
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 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
parallel: a Go Parallel Processing Library
parallel: a Go Parallel Processing Library Concurrency is hard. This library doesn't aim to make it easy, but it will hopefully make it a little less
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
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
Work pool channlege - An url hash retriever worker pool for getting hash digest for a collection of urls
Code challenge The aim of this project is to provide an url hash retriever worke
Linstor-wait-until - Waits until a specific component of LINSTOR is online and usable
linstor-wait-until Waits until a specific component of LINSTOR is online and usa
Golang Implementation of Worker Pool/ Thread Pool
Golang Implementation of Worker Pool/ Thread Pool
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
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