parallel-fn alternatives and similar packages

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

ants

9.6 5.5 parallel-fn VS ants

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

8.8 0.0 parallel-fn VS tunny

A goroutine pool for Go

Delete the most useless function ever: context switching.

Zigi monitors Jira and GitHub updates, pings you when PRs need approval and lets you take fast actions - all directly from Slack! Plus it reduces cycle time by up to 75%.

Promo www.zigi.ai

goworker

8.6 0.0 parallel-fn 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 parallel-fn VS grpool

Lightweight Goroutine pool
pool

7.1 0.0 parallel-fn VS pool

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

6.9 5.1 parallel-fn VS pond

🔘 Minimalistic and High-performance goroutine worker pool written in Go
gowp

6.5 2.1 parallel-fn VS gowp

golang worker pool , Concurrency limiting goroutine pool
go-floc

5.6 0.0 parallel-fn VS go-floc

Floc: Orchestrate goroutines with ease.
Goflow

5.4 0.0 parallel-fn VS Goflow

Simply way to control goroutines execution order based on dependencies
go-workers

4.8 0.0 parallel-fn VS go-workers

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

4.8 0.0 parallel-fn VS semaphore go

Fast resizable golang semaphore primitive
artifex

4.8 0.0 parallel-fn VS artifex

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

4.7 0.0 parallel-fn 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.
neilotoole/errgroup

4.7 0.0 parallel-fn VS neilotoole/errgroup

errgroup with goroutine worker limits
cyclicbarrier

4.4 0.0 parallel-fn VS cyclicbarrier

CyclicBarrier golang implementation
GoSlaves

4.4 0.0 parallel-fn VS GoSlaves

Simple and Asynchronous Goroutine pool library.
gollback

4.2 1.9 parallel-fn VS gollback

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

4.2 0.0 parallel-fn VS workerpool

Go simple async worker pool
Syncs

4.2 1.7 parallel-fn VS Syncs

Concurrency and synchronization primitives
threadpool

4.1 0.0 parallel-fn VS threadpool

Golang simple thread pool implementation
Hunch

4.0 2.1 parallel-fn VS Hunch

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

4.0 0.0 parallel-fn VS semaphore

🚦 Semaphore pattern implementation with timeout of lock/unlock operations.
go-do-work

3.8 0.0 parallel-fn VS go-do-work

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

3.7 0.0 parallel-fn VS gpool

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

3.4 0.0 parallel-fn VS goccm

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

3.3 0.0 parallel-fn VS routine

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

3.1 0.0 parallel-fn VS nursery

Structured Concurrency in Go
gohive

2.9 0.0 parallel-fn VS gohive

🐝 A Highly Performant and easy to use goroutine pool for Go
go-trylock

2.7 0.0 parallel-fn VS go-trylock

TryLock support on read-write lock for Golang
gowl

2.6 5.2 parallel-fn 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.
kyoo

2.6 0.0 parallel-fn VS kyoo

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

2.5 0.0 parallel-fn VS go-waitgroup

A sync.WaitGroup with error handling and concurrency control
Bifrost

2.2 0.0 parallel-fn VS Bifrost

Golang query-able job queue
channelify

2.1 0.0 parallel-fn VS channelify

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

1.7 0.0 parallel-fn VS caster

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

1.6 0.0 parallel-fn VS Flow

Package flow provides support for basic FBP / pipelines
conexec

1.6 0.0 parallel-fn 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.
execpool

1.6 0.0 parallel-fn VS execpool

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

1.5 7.9 parallel-fn VS go-actor

A tiny library for writing concurrent programs in Go using actor model
hands

1.4 0.0 parallel-fn VS hands

Hands is a process controller used to control the execution and return strategies of multiple goroutines.
go-tools/multithreading

1.3 0.0 parallel-fn VS go-tools/multithreading

A collection of tools for Golang
concurrency-limiter

1.2 0.0 parallel-fn VS concurrency-limiter

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

1.2 0.0 parallel-fn 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.
WorkerGo

1.1 0.0 parallel-fn VS WorkerGo

A worker pool implementation for Go
sworker

0.6 0.5 parallel-fn VS sworker

Easy worker setup for your code
go-workerpool

0.6 10.0 parallel-fn VS go-workerpool

Go WorkerPool aims to control heavy Go Routines
async-job

0.5 4.6 parallel-fn VS async-job

AsyncJob is an asynchronous queue job manager with light code, clear and speed. I hope so ! 😬
breaker

0.5 0.0 parallel-fn VS breaker

🚧 Flexible mechanism to make execution flow interruptible.
github.com/akshaybharambe14/gowp

0.4 0.0 parallel-fn VS github.com/akshaybharambe14/gowp

High performance, type safe, concurrency limiting worker pool package for golang!
Generic worker pool

0.2 10.0 parallel-fn VS Generic worker pool

Go (1.18+) framework to run a pool of N workers

Do you think we are missing an alternative of parallel-fn or a related project?

Add another 'Goroutines' Package

Popular Comparisons

README

Parallel fn

Run functions in parallel.
Limit the number of goroutines running at the same time.

Installation

go get -u github.com/rafaeljesus/parallel-fn

Usage

Run

package main

import (
    "errors"

    "github.com/rafaeljesus/parallel-fn"
)

func main() {
    timeout := time.After(2 * time.Second)
        fn1 := func() error { return nil }
        fn2 := func() error { return errors.New("BOOM!") }

    for {
        select {
        case err := <-Run(fn1, fn2):
                    // catch errors
        case <-timeout:
                // handle timeout
        }
    }
}

RunLimit

package main

import (
    "errors"

    "github.com/rafaeljesus/parallel-fn"
)

func main() {
    timeout := time.After(2 * time.Second)
    fn1 := func() error { return nil }
    fn2 := func() error { return errors.New("BOOM!") }
    fn3 := func() error { nil }
    fn4 := func() error { nil }

    for {
        select {
        case err := <-RunLimit(2, fn1, fn2, fn3, fn4):
                // catch errors
        case <-timeout:
                // handle timeout
        }
    }
}