Popularity

3.9

Declining

Activity

0.0

Declining

Stars 84

Watchers 1

Forks 9

Last Commit about 1 year ago

Programming language: Go

License: MIT License

Tags: Goroutines

Latest version: v4.4.1

semaphore alternatives and similar packages

Based on the "Goroutines" category.
Alternatively, view semaphore alternatives based on common mentions on social networks and blogs.

ants

9.4 6.0 semaphore VS ants

🐜🐜🐜 ants is a high-performance and low-cost goroutine pool in Go, inspired by fasthttp./ ants 是一个高性能且低损耗的 goroutine 池。
tunny

8.7 2.8 semaphore VS tunny

A goroutine pool for Go

Scout APM - Leading-edge performance monitoring starting at $39/month

Scout APM uses tracing logic that ties bottlenecks to source code so you know the exact line of code causing performance issues and can get back to building a great product faster.

Sponsored scoutapm.com

goworker

8.7 1.7 semaphore VS goworker

goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.
grpool

7.2 0.0 semaphore VS grpool

Lightweight Goroutine pool
pool

7.0 0.0 semaphore VS pool

:speedboat: a limited consumer goroutine or unlimited goroutine pool for easier goroutine handling and cancellation
gowp

6.2 2.4 semaphore VS gowp

golang worker pool , Concurrency limiting goroutine pool
go-floc

5.4 0.0 semaphore VS go-floc

Floc: Orchestrate goroutines with ease.
pond

5.4 3.1 semaphore VS pond

Minimalistic and High-performance goroutine worker pool written in Go
Goflow

5.2 0.0 semaphore VS Goflow

Simply way to control goroutines execution order based on dependencies
artifex

4.5 1.4 semaphore VS artifex

Simple in-memory job queue for Golang using worker-based dispatching
GoSlaves

4.4 0.0 semaphore VS GoSlaves

Simple and Asynchronous Goroutine pool library.
async

4.4 0.6 semaphore VS async

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.
semaphore go

4.4 0.0 semaphore VS semaphore go

Fast resizable golang semaphore primitive
go-workers

4.2 7.8 semaphore VS go-workers

👷 Library for safely running groups of workers concurrently or consecutively that require input and output through channels
breaker

4.1 5.5 semaphore VS breaker

🚧 Flexible mechanism to make execution flow interruptible.
workerpool

4.1 0.0 semaphore VS workerpool

Go simple async worker pool
go-do-work

3.9 0.0 semaphore VS go-do-work

Dynamically resizable pools of goroutines which can queue an infinite number of jobs.
neilotoole/errgroup

3.8 2.1 semaphore VS neilotoole/errgroup

errgroup with goroutine worker limits
threadpool

3.7 0.0 semaphore VS threadpool

Golang simple thread pool implementation
cyclicbarrier

3.6 0.1 semaphore VS cyclicbarrier

CyclicBarrier golang implementation
gpool

3.6 0.0 semaphore VS gpool

gpool - a generic context-aware resizable goroutines pool to bound concurrency based on semaphore.
Syncs

3.2 0.0 semaphore VS Syncs

Concurrency and synchronization primitives
gollback

3.2 0.0 semaphore VS gollback

Go asynchronous simple function utilities, for managing execution of closures and callbacks
Hunch

3.1 3.1 semaphore VS Hunch

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

2.9 0.8 semaphore VS routine

go routine control, abstraction of the Main and some useful Executors.如果你不会管理Goroutine的话，用它
nursery

2.6 0.8 semaphore VS nursery

Structured Concurrency in Go
parallel-fn

2.4 0.0 semaphore VS parallel-fn

Run functions in parallel :comet:
Bifrost

2.4 0.0 semaphore VS Bifrost

Golang query-able job queue
kyoo

2.3 0.0 semaphore VS kyoo

Unlimited job queue for go, using a pool of concurrent workers processing the job queue entries
go-trylock

2.1 1.0 semaphore VS go-trylock

TryLock support on read-write lock for Golang
goccm

1.9 0.0 semaphore VS goccm

Limits the number of goroutines that are allowed to run concurrently
gohive

1.7 0.0 semaphore VS gohive

🐝 A Highly Performant and easy to use goroutine pool for Go
Flow

1.7 0.3 semaphore VS Flow

Package flow provides support for basic FBP / pipelines
caster

1.6 0.0 semaphore VS caster

Dead simple and performant message broadcaster (pubsub) for Go
go-waitgroup

1.5 0.0 semaphore VS go-waitgroup

A sync.WaitGroup with error handling and concurrency control
conexec

1.4 0.1 semaphore VS conexec

A concurrent toolkit to help execute funcs concurrently in an efficient and safe way. It supports specifying the overall timeout to avoid blocking.
channelify

1.3 1.2 semaphore VS channelify

Make functions return a channel for parallel processing via go routines.
gowl

1.2 6.1 semaphore VS gowl

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.
go-tools/multithreading

1.1 0.0 semaphore VS go-tools/multithreading

A collection of tools for Golang
WorkerGo

1.0 0.0 semaphore VS WorkerGo

A worker pool implementation for Go
hands

0.9 0.0 semaphore VS hands

Hands is a process controller used to control the execution and return strategies of multiple goroutines.
queue

0.9 0.0 semaphore VS queue

package queue gives you a queue group accessibility. Helps you to limit goroutines, wait for the end of the all goroutines and much more.
sworker

0.7 0.6 semaphore VS sworker

Easy worker setup for your code
concurrency-limiter

0.7 6.7 semaphore VS concurrency-limiter

Concurrency limiter with support for timeouts , dynamic priority and context cancellation of goroutines.
oversight

- semaphore VS oversight

Oversight is a complete implementation of the Erlang supervision trees.

Do you think we are missing an alternative of semaphore or a related project?

Add another 'Goroutines' Package

Popular Comparisons

README

🚦 semaphore

Semaphore pattern implementation with timeout of lock/unlock operations.

💡 Idea

The semaphore provides API to control access to a shared resource by multiple goroutines or limit throughput.

releaser, err := semaphore.Acquire(breaker.BreakByTimeout(time.Second))
if err != nil {
    // timeout exceeded
}
defer releaser.Release()

Full description of the idea is available here.

🏆 Motivation

...

🤼‍♂️ How to

Quick start

limiter := semaphore.New(1000)

http.HandleFunc("/", func(rw http.ResponseWriter, req *http.Request) {
    if _, err := limiter.Acquire(
        breaker.BreakByContext(
            context.WithTimeout(req.Context(), time.Second),
        ),
    ); err != nil {
        http.Error(rw, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests)
        return
    }
    defer limiter.Release()

    // handle request
})

log.Fatal(http.ListenAndServe(":80", http.DefaultServeMux))

🧩 Integration

The library uses SemVer for versioning, and it is not BC-safe through major releases. You can use go modules or dep to manage its version.

The master is a feature frozen branch for versions 4.3.x and no longer maintained.

$ dep ensure -add github.com/kamilsk/[email protected]

The v4 branch is a continuation of the master branch for versions v4.4.x to better integration with go modules.

$ go get -u github.com/kamilsk/semaphore/[email protected]

The v5 branch is an actual development branch.

$ go get -u github.com/kamilsk/semaphore    # inside GOPATH and for old Go versions

$ go get -u github.com/kamilsk/semaphore/v5 # inside Go module, works well since Go 1.11

$ dep ensure -add github.com/kamilsk/[email protected]

Version v5 focused on integration with the 🚧 breaker package.

🤲 Outcomes

Console tool for command execution in parallel

This example shows how to execute many console commands in parallel.

$ semaphore create 2
$ semaphore add -- docker build
$ semaphore add -- vagrant up
$ semaphore add -- ansible-playbook
$ semaphore wait --timeout=1m --notify

See more details here.

made with ❤️ for everyone

semaphore

🚦 Semaphore pattern implementation with timeout of lock/unlock operations.