async Alternatives - Go Goroutines

Popularity

4.3

Growing

Activity

1.2

Declining

Stars 69

Watchers 12

Forks 10

Last Commit 3 months ago

Programming language: Go

License: GNU General Public License v3.0 or later

Tags: Goroutines

Latest version: v1.0.0

async alternatives and similar packages

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

ants

9.4 4.7 async VS ants

🐜⚡️A high-performance goroutine pool in Go, inspired by fasthttp.
goworker

8.7 2.6 async VS goworker

goworker is a Go-based background worker

Get performance insights in less than 4 minutes

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

tunny

8.5 0.0 async VS tunny

A goroutine pool for golang.
grpool

7.2 0.0 async VS grpool

Lightweight Goroutine pool.
pool

7.0 0.0 async VS pool

Go consumer goroutine pool for easy goroutine handling + time saving.
gowp

6.0 1.0 async VS gowp

gowp is concurrency limiting goroutine pool.
go-floc

5.3 0.0 async VS go-floc

Orchestrate goroutines with ease.
Goflow

5.1 0.0 async VS Goflow

Simply way to control goroutines execution order based on dependencies
pond

5.1 3.0 async VS pond

Minimalistic and High-performance goroutine worker pool written in Go.
artifex

4.4 2.4 async VS artifex

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

4.4 0.0 async VS GoSlaves

Simple and Asynchronous Goroutine pool library.
semaphore go

4.3 1.1 async VS semaphore go

Fast resizable golang semaphore
workerpool

4.1 0.8 async VS workerpool

goworker is a Go simple async worker pool.
breaker

4.1 0.5 async VS breaker

Flexible mechanism to make execution flow interruptible.
go-workers

4.0 7.7 async VS go-workers

Easily and safely run workers for large data processing pipelines.
semaphore

4.0 0.2 async VS semaphore

Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context.
go-do-work

3.9 0.0 async VS go-do-work

Dynamically resizable pools of goroutines which can queue an infinite number of jobs.
threadpool

3.6 0.4 async VS threadpool

Golang threadpool implementation.
gpool

3.5 0.0 async VS gpool

manages a resizeable pool of context-aware goroutines to bound concurrency.
cyclicbarrier

3.4 0.4 async VS cyclicbarrier

CyclicBarrier for golang.
neilotoole/errgroup

3.4 4.4 async VS neilotoole/errgroup

Drop-in alternative to sync/errgroup, limited to a pool of N worker goroutines.
gollback

3.0 1.2 async VS gollback

asynchronous simple function utilities, for managing execution of closures and callbacks.
Syncs

2.9 0.5 async VS Syncs

additional synchronization primitives
routine

2.8 1.3 async VS routine

go routine control with context, support: Main, Go, Pool and some useful Executors.
Hunch

2.8 4.2 async VS Hunch

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

2.6 1.1 async VS nursery

Structured concurrency in Go.
parallel-fn

2.4 0.0 async VS parallel-fn

Run functions in parallel.
kyoo

2.3 0.3 async VS kyoo

Provides an unlimited job queue and concurrent worker pools.
Bifrost

2.2 0.0 async VS Bifrost

Golang query-able job queue
gohive

1.8 0.0 async VS gohive

A highly performant and easy to use Goroutine pool for Go.
go-trylock

1.8 0.0 async VS go-trylock

TryLock support on read-write lock for Golang.
goccm

1.8 1.1 async VS goccm

Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently.
Flow

1.7 1.2 async VS Flow

FBP / pipelines
go-waitgroup

1.5 0.0 async VS go-waitgroup

Like sync.WaitGroup with error handling and concurrency control.
caster

1.5 0.0 async VS caster

Dead simple and performant message broadcaster (pubsub) for Go
conexec

1.3 0.4 async 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 and uses goroutine pool to improve efficiency.
go-tools/multithreading

1.1 0.0 async VS go-tools/multithreading

Manage a pool of goroutines using this lightweight library with a simple API.
WorkerGo

0.9 0.4 async VS WorkerGo

A worker pool implementation for Go
queue

0.9 0.0 async VS queue

Gives you a sync.WaitGroup like queue group accessibility. Helps you to throttle and limit goroutines, wait for the end of the all goroutines and much more.
hands

0.9 2.4 async VS hands

A process controller used to control the execution and return strategies of multiple goroutines.
channelify

0.8 1.8 async VS channelify

Transform your function to return channels for easy and powerful parallel processing.
concurrency-limiter

0.7 7.1 async VS concurrency-limiter

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

0.7 2.1 async VS sworker

Go easy worker setup for your code
oversight

- async VS oversight

Oversight is a complete implementation of the Erlang supervision trees.

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

Add another 'Goroutines' Package

Popular Comparisons

README

Async

Provides 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, and a simple way to control execution flow without WaitGroup.

Usage

var (
    user   User
    songs  []Songs
    photos []Photos
)

err := async.Run(ctx,
    func(ctx context.Context) error {
        user, err = user.Get(ctx, id)
        return err
    },
    func(ctx context.Context) error {
        songs, err = song.GetByUserID(ctx, id)
        return err
    },
    func(ctx context.Context) error {
        photos, err = photo.GetByUserID(ctx, id)
        return err
    },
)

if err != nil {
    log.Error(err)
}

You can also limit the number of asynchronous tasks

runner := async.NewRunner(tasks...).WithLimit(3)
if err := runner.Run(ctx); err != nil { 
    log.Error(e)
}

async

A safe way to execute functions asynchronously, recovering them in case of panic.

async alternatives and similar packages

Popular Comparisons

README

Async

Usage