103 Resources
Golang worker-pool Libraries
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
Tasqueue is a simple, lightweight distributed job/worker implementation in Go
Tasqueue Tasqueue is a simple, lightweight distributed job/worker implementation in Go Concepts tasqueue.Broker is a generic interface that provides m
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
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
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
Worker - A Golang library that provides worker pools
Worker A Golang library that provides worker pools. Usage See *_test.go files. T
Go-miningcore-pool - Miningcore Pool written in GOlang
Go-Miningcore-Pool (COMING SOON) Miningcore Pool written in GOlang 0x01 Configur
Goworkers - Zero dependency Golang worker pool
Golang Worker Pool Zero dependency golang goroutines pool library. It is useful
Drain-my-spot - Service draining the k8s worker node in case of spot instances related event occurrence
drain-my-spot Service draining the k8s worker node in case of spot instances rel
This library is a complementary library for Gorm (v2) which resolves the first available pool passed to it.
This library is a complementary library for Gorm (v2) which resolves the first available pool passed to it.
Golang Implementation of Worker Pool/ Thread Pool
Golang Implementation of Worker Pool/ Thread Pool
TechTalk: Procesamiento masivo de datos con Go y sync.Pool
Procesamiento masivo de datos en Go Si quieres probarlo, descarga alguno de los
Poweth - Etchash go module intended for use by core-pool (and open-ethereum-pool)
go-etchash Etchash go module intended for use by core-pool (and open-ethereum-po
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
A buffer pool file I/O library for Go
bfile A buffer pool file I/O library for Go. The purpose of the library is to provide I/O mechanisms for copying data to and from a buffer in user spa
A pool that spins up a given number of processes in advance and attaches stdin and stdout when needed
A pool that spins up a given number of processes in advance and attaches stdin and stdout when needed. Very similar to FastCGI but works for any command.
A TCP Library use worker pool to improve performance and protect your server
A TCP Library use worker pool to improve performance and protect your server
Go-async - Worker pool (fan-in/fan-out)
Worker pool (fan-in/fan-out) func main() { pool := worker.NewPool(2) ctx := co
Toolkit - Collection of useful patterns
toolkit Introduction These patterns can you use to solve common problems when designing an application or system. Requirements golang =1.11.x - The G
Go-postgres - go-postgres library provide NoSQL functionality which can execute queries with pool of connections
GO Postgres go-postgres library provide NoSQL functionality which can execute queries with pool of connections. What is this repository for? Establish
Snowflake algorithm generation worker Id sequence
sequence snowflake algorithm generation worker Id sequence 使用雪花算法生成ID，生成100万个只需要
a Framework for creating microservices using technologies and design patterns of Erlang/OTP in Golang
Technologies and design patterns of Erlang/OTP have been proven over the years. Now in Golang. Up to x5 times faster than original Erlang/OTP in terms
Golang query-able job queue
ᛉ Bifröst - a queryable in-process worker queue Package bifrost contains functionality to create an in-process job queue with a configurable number of
A worker pool implementation for Go
WorkerGo WorkerGo is an MIT licensed worker pool implementation that can be used in any Go program to handle tasks with workers. WorkerGo is heavily i
Buffer pool with capacity in order to prevent from excess memory usage and CPU trashing.
Buffer pool prevent from excess memory usage and CPU trashing. Quick Start To import bpool from source code use go get command. go get -u github.com/u
A mining pool proxy tool, support BTC, ETH, ETC, XMR mining pool, etc.
Tier2Pool A mining pool proxy tool, support BTC, ETH, ETC, XMR mining pool, etc. Build I use Ubuntu as a demo. sudo update sudo apt install git make s
High performance, type safe, concurrency limiting worker pool package for golang!
GOWP Package gowp (Go Worker-Pool) provides concurrency limiting, error propagation, and Context cancellation for a group of workers/goroutines. Featu
Open-source tonuniverse mining pool client
miningPoolCli Open-source mining pool client To use with tonuniverse mining pool, follow the instructions at https://tonuniverse.com Source code You c
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
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
Support variable parameters task send worker
go-worker-pool Support variable parameters task send worker 调用方式 go get github.com/214200196/gwp/v1 import ( "fmt" "github.com/214200196/gwp/v1" "
The Stratum-based mining pool performance test tool.
stratum-ping Abstract Often the performance of various mining pools is verified using the built-in ping utility. While this approach is feasible, it i
Open Source Etho Mining Pool - tuned for 8000000 block hardfork on EthoProtocol blockchain.
Open Source Etho Mining Pool - tuned for 8000000 block hardfork on EthoProtocol blockchain. image to be updated soon! Features This pool is being furt
Linux GUI viewer for ZFS pool, dataset and host storage.
This is a WIP in alpha stage. zgui Linux GUI viewer for ZFS pool, dataset and host storage. zgui used libzfs directly and not ZFS command line tools.
Dcrpool : a stratum decred mining pool
dcrpool dcrpool is a stratum decred mining pool. It currently supports: Innosilicon D9 (default port: 5552, supported firmware: D9_20180602_094459.swu
Open Source Ethereum Mining Pool With Go
Open Source Ethereum Mining Pool Features This pool is being further developed to provide an easy to use pool for Ethereum miners. This software is fu
Monitor the performance of your Ethereum 2.0 staking pool.
eth-pools-metrics Monitor the performance of your Ethereum 2.0 staking pool. Just input the withdrawal credentials that were used in the deposit contr
Tiny library to handle background jobs.
bgjob Tiny library to handle background jobs. Use PostgreSQL to organize job queues. Highly inspired by gue Features Durable job storage At-least-ones
GBPool-- a simple but useful golang free proxy pool
GBPool-- a simple but useful golang free proxy pool Intro(English) (中文) GBPool, golang baipiao proxy pool, a free & simple golang proxy pool module, g
Deadly simple worker pool
go-worker-pool Deadly simple worker pool Usage package main import ( "errors" workerpool "github.com/zelenin/go-worker-pool" "log" "time" ) func
Go lang concurrency with channels and worker pools using sync.Pools.
Go Concurrency Go lang concurrency with channels and worker pools using sync.Pools. Concurrency Concurrency is an ability of a program to do multiple
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
🧮 SOCKS5/4/4a 🌾 validating proxy pool for 🤽 LOLXDsoRANDum connections 🎋
Prox5 SOCKS5/4/4a validating proxy pool This package is for managing and accessing thousands upon thousands of arbitrary SOCKS proxies. It also has a
Go worker library
gorkers Examples Quickstart Multiple Go Workers Passing Fields Getting Started Import import ( "github.com/guilhem/gorkers" ) Create a worker func
SOCKS5/4/4a validating proxy pool. Water's fine on my machine!
PxndScvm SOCKS5/4/4a validating proxy pool This package is for managing and accessing thousands upon thousands of arbitrary SOCKS proxies. Pipe it a f
🐺 Garment retains a single connection pool for different database types used inside you application
Garment A Thread Safe Connection Pooling. Garment retains a single connection pool for different database types used inside you application (MySQL, Re
Golang实现的免费IP池
项目基于 go + goquery + gin + xorm 实现的 IP池 服务，每日多个时段进行IP池数据扩充，定时进行存活检测。 采用mysql作为数据持久化存储
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.
Routines was a fixed number thread pool to process the user task, and it would respawn a corresponding new thread when panic
Routines Routines was a fixed number thread pool to process the user task, and it would respawn a corresponding new thread when panic. It supports 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
YTask is an asynchronous task queue for handling distributed jobs in golang
YTask is an asynchronous task queue for handling distributed jobs in golang
a Framework for creating microservices using technologies and design patterns of Erlang/OTP in Golang
Technologies and design patterns of Erlang/OTP have been proven over the years. Now in Golang. Up to x5 times faster than original Erlang/OTP in terms
A golang universal connections pool.
gopool A golang universal connection pool. Features: Using arrays instead of channels to improve performance Automatically detect live server nodes an
Simple, efficient background processing for Golang backed by RabbitMQ and Redis
Table of Contents How to Use Motivation Requirements Features Examples Setup Config Client/Server Task Worker/Task Hander Register The Handlers Send t
Concurrency in Go video course with in depth explanations & examples
Concurrency in Go Summary Coding Examples Introduction to Concurrency Go Routines Channels Select Concurrency Patterns Atomics Wait Groups - sync.Wait
Kubei is a flexible Kubernetes runtime scanner, scanning images of worker and Kubernetes nodes providing accurate vulnerabilities assessment, for more information checkout:
Kubei is a vulnerabilities scanning and CIS Docker benchmark tool that allows users to get an accurate and immediate risk assessment of their kubernet
ConnPool is a thread safe connection pool for net.Conn interface.
ConnPool is a thread safe connection pool for net.Conn interface. It can be used to manage and reuse connections.
The pool price management bot to stabilize overpriced pools
The pool price management bot to stabilize overpriced pools during the Gravity DEX incentivized testnet. This project is developed solely for the purpose of pool price management during the incentivized testnet.
Worker failover support for PostgreSQL Citus extension using pg_auto_failover.
citus-failover Worker failover support for citus community version using pg_auto_failover. What is this? This is a simple service to monitor changes i
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.
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.
gin api blog
Gin项目 介绍 以下是基于gin开发的项目接口，将持续更新，有兴趣请star，本项目包含mysql，redis，elasticsearch，mongo，rabbitmq，kafka，jaeger，单机限流，分布式限流，sentry, jwt，请求参数验证，发送邮件，图片上传，httpclient用
Job worker service that provides an API to run arbitrary Linux processes.
Job Scheduler Summary Prototype job worker service that provides an API to run arbitrary Linux processes. Overview Library The library (Worker) is a r
Helper library for full uint64 randomness, pool backed for efficient concurrency
fastrand64-go Helper library for full uint64 randomness, pool backed for efficient concurrency Inspired by https://github.com/valyala/fastrand which i
A lightweight job scheduler based on priority queue with timeout, retry, replica, context cancellation and easy semantics for job chaining. Build for golang web apps.
Table of Contents Introduction What is RIO? Concern An asynchronous job processor Easy management of these goroutines and chaining them Introduction W
🍀 Go basic library. || Go语言基础库
Go语言基础库 工程目录说明 pkg/ ...... 源码包 |-- bininfo/ ...... 将编译时源码的git版本信息（当前commit log的sha值和commit message），编译时间，Go版本，平台打入程序中
go语言扩展包，收集一些常用的操作函数，辅助更快的完成开发工作，并减少重复代码
go-extend go-extend 收集一些常用的操作函数，辅助更快的完成开发工作，并减少重复代码。 它收集各种杂项函数，并进行归类，方便使用者查找，它可以大幅度提升开发效率和程序运行性能。它以保证性能为最大前提，提供有效的方法。 针对一些标准库中的函数或者库进行一些修改，使其性能大幅度提升，但
Asynq: simple, reliable, and efficient distributed task queue in Go
Asynq: simple, reliable, and efficient distributed task queue in Go
a Framework for creating mesh networks using technologies and design patterns of Erlang/OTP in Golang
Ergo Framework Implementation of Erlang/OTP in Golang. Up to x5 times faster than original Erlang/OTP. The easiest drop-in replacement for your hot no
go task pool
Task Pool Task Pool 是一个易于使用且高度可配置的 golang类库，专门用于任务的管理&执行，支持自定义次数的重发。 功能特点 线程安全 - task pool 内所有的方法以及暴露的接口都是线程安全的 异步发送 - 调用 PushTask 方法后回立即返回，任务将会被传递到io
Efficient and reliable background processing for Go
CurlyQ CurlyQ provides a simple, easy-to-use interface for performing background processing in Go. It supports scheduled jobs, job deduplication, and
Distributed Task Scheduling System|分布式定时任务调度平台
Crocodile Distributed Task Scheduling System English | 中文 Introduction A distributed task scheduling system based on Golang that supports http request
NSQProxy是NSQ和Worker之间的中间件，根据配置负责消息转发。
NSQProxy NSQProxy是Golang开发的NSQ和Worker之间的中间件，根据数据库配置，负责消息转发。NSQProxy启动后，接受NSQD队列内容，然后通过HTTP/FastCGI/CBNSQ等协议转发给Worker机执行。在唱吧内部使用2年，高效稳定的处理着每日数十亿条消息。
A better Generic Pool (sync.Pool)
This package is a thin wrapper over the Pool provided by the sync package. The Pool is an essential package to obtain maximum performance by reducing the number of memory allocations.
Go worker pool
description This is a generic worker pool for the Go language. It's useful when you want to limit the number of goroutines running in parallel. instal
a generic object pool for golang
Go Commons Pool The Go Commons Pool is a generic object pool for Golang, direct rewrite from Apache Commons Pool. Features Support custom PooledObject
🚀 gnet is a high-performance, lightweight, non-blocking, event-driven networking framework written in pure Go./ gnet 是一个高性能、轻量级、非阻塞的事件驱动 Go 网络框架。
English | 🇨🇳 中文 📖 Introduction gnet is an event-driven networking framework that is fast and lightweight. It makes direct epoll and kqueue syscalls
An opinionated productive web framework that helps scaling business easier.
appy An opinionated productive web framework that helps scaling business easier, i.e. focus on monolith first, only move to microservices with GRPC la
A persistent and flexible background jobs library for go.
Jobs Development Status Jobs is no longer being actively developed. I will still try my best to respond to issues and pull requests, but in general yo
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
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
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
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
: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
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
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
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
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
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
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
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
🐝 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
👷 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 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