Filter By
70 Resources
Golang Goroutines
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
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
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
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
👷 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
A universal mechanism to manage goroutine lifecycles
A universal mechanism to manage goroutine lifecycles
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
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
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.
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.
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
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
🐜🐜🐜 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
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
: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
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() {
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
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
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
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
高性能go协程池，代码清晰易懂
gowp 高性能go协程池，代码清晰易懂 安装 go get github.com/linzhepeng/gowp 为什么要用协程池 go的协程虽然轻量级，单个goroutine只有2KB，但毫无止境地使用也会占据大量的系统资源，导致调度性能下降、GC 频繁、内存暴涨, 引发一系列问题。 可以测试如
Routine - ThreadLocal for golang
routine 中文版 routine encapsulates and provides some easy-to-use, high-performance
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
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
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
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
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
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
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
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
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
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
Go-async - Worker pool (fan-in/fan-out)
Worker pool (fan-in/fan-out) func main() { pool := worker.NewPool(2) ctx := co
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
Structured Concurrency in Go
nursery: structured concurrency in Go RunConcurrently( // Job 1 func(context.Context, chan error) { time.Sleep(time.Millisecond * 10)
🚧 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
🐝 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
🚦 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 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 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
Software Transactional Locks
Software Transactional Locks Package stl provides multiple atomic dynamic shared/exclusive locks, based on Software Transactional Memory (STM) concurr
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
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
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
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
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
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
Goworkers - Zero dependency Golang worker pool
Golang Worker Pool Zero dependency golang goroutines pool library. It is useful
Go-miningcore-pool - Miningcore Pool written in GOlang
Go-Miningcore-Pool (COMING SOON) Miningcore Pool written in GOlang 0x01 Configur