parallel-fn Alternatives - Go Goroutines

Popularity

2.4

Growing

Activity

0.0

Stable

Stars 29

Watchers 3

Forks 1

Last Commit about 3 years ago

Programming language: Go

License: MIT License

Tags: Goroutines

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.4 4.7 parallel-fn VS ants

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

8.7 2.6 parallel-fn 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 parallel-fn VS tunny

A goroutine pool for golang.
grpool

7.2 0.0 parallel-fn VS grpool

Lightweight Goroutine pool.
pool

7.0 0.0 parallel-fn VS pool

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

6.0 1.0 parallel-fn VS gowp

gowp is concurrency limiting goroutine pool.
go-floc

5.3 0.0 parallel-fn VS go-floc

Orchestrate goroutines with ease.
Goflow

5.1 0.0 parallel-fn VS Goflow

Simply way to control goroutines execution order based on dependencies
pond

5.1 3.0 parallel-fn VS pond

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

4.4 2.4 parallel-fn VS artifex

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

4.4 0.0 parallel-fn VS GoSlaves

Simple and Asynchronous Goroutine pool library.
async

4.3 1.2 parallel-fn VS async

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

4.3 1.1 parallel-fn VS semaphore go

Fast resizable golang semaphore
breaker

4.1 0.5 parallel-fn VS breaker

Flexible mechanism to make execution flow interruptible.
workerpool

4.1 0.8 parallel-fn VS workerpool

goworker is a Go simple async worker pool.
go-workers

4.0 7.7 parallel-fn VS go-workers

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

4.0 0.2 parallel-fn VS semaphore

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

3.9 0.0 parallel-fn VS go-do-work

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

3.6 0.4 parallel-fn VS threadpool

Golang threadpool implementation.
gpool

3.5 0.0 parallel-fn VS gpool

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

3.4 0.4 parallel-fn VS cyclicbarrier

CyclicBarrier for golang.
neilotoole/errgroup

3.4 4.4 parallel-fn VS neilotoole/errgroup

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

3.0 1.2 parallel-fn VS gollback

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

2.9 0.5 parallel-fn VS Syncs

additional synchronization primitives
Hunch

2.8 4.2 parallel-fn VS Hunch

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

2.8 1.3 parallel-fn VS routine

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

2.6 1.1 parallel-fn VS nursery

Structured concurrency in Go.
kyoo

2.3 0.3 parallel-fn VS kyoo

Provides an unlimited job queue and concurrent worker pools.
Bifrost

2.2 0.0 parallel-fn VS Bifrost

Golang query-able job queue
gohive

1.8 0.0 parallel-fn VS gohive

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

1.8 0.0 parallel-fn VS go-trylock

TryLock support on read-write lock for Golang.
goccm

1.8 1.1 parallel-fn VS goccm

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

1.7 1.2 parallel-fn VS Flow

FBP / pipelines
caster

1.5 0.0 parallel-fn VS caster

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

1.5 0.0 parallel-fn VS go-waitgroup

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

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

1.1 0.0 parallel-fn VS go-tools/multithreading

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

0.9 0.4 parallel-fn VS WorkerGo

A worker pool implementation for Go
queue

0.9 0.0 parallel-fn 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 parallel-fn VS hands

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

0.8 1.8 parallel-fn VS channelify

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

0.7 7.1 parallel-fn VS concurrency-limiter

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

0.7 2.1 parallel-fn VS sworker

Go easy worker setup for your code
oversight

- parallel-fn VS oversight

Oversight is a complete implementation of the Erlang supervision trees.

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
        }
    }
}