Popularity
1.8
Growing
Activity
5.8
Declining
11
3
1

Programming language: Go
Tags: Goroutines    

gohive alternatives and similar packages

Based on the "Goroutines" category

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

Add another 'Goroutines' Package

README

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 requirement
  • Offers efficient performance by implementing sync.Pool, which maintains pool of workers in which workers gets recycled automatically when not in use
  • Implements a Task Queue which can hold surplus tasks in waiting, if submitted more than the pool capacity
  • Implements PoolService type, which acts as an easy to use API with simple methods to interact with gohive
  • Gracefully handles panics and prevent the application from getting crashed or into deadlocks
  • Provides functions like: AvailableWorkers(), ActiveWorkers() and Close() etc.

Installation

Use go get to install and update:

$ go get -u github.com/loveleshsharma/gohive

Usage

  • Create an instance of PoolService type first
hive := gohive.NewFixedSizePool(5)
  • Invoke the Submit() function and pass the task to execute
hive.Submit(someTask())

Submit function accepts a function as an argument, which it passes to the pool if a worker is available, otherwise enqueues it in a waiting queue

  • To close the pool we can invoke the Close() function
hive.Close()

Once the pool is closed, we cannot assign any task to it

Example

Let's get into a full program where we can see how to use the gohive package in order to execute many goroutines simultaneously

package main

import (
    "github.com/loveleshsharma/gohive"
    "fmt"
    "sync"
)

func main() {

    var wg sync.WaitGroup
    hivePool := gohive.NewFixedSizePool(5)

    //wrap your executable function into another function with wg.Done()
    executableTask := func() {
        defer wg.Done()
        factorial(5)
    }

    wg.Add(1)
    hivePool.Submit(executableTask)

    wg.Wait()
}

func factorial(val int) {
    var fact = val
    var res = 1

    for i := fact; i > 0; i-- {
        res = res * i
    }

    fmt.Printf("Factorial: %v", res)
}

Important : Always put defer wg.Done() as the first statement of your wrapper function. It will prevent your program from deadlocks in case of panics

Workers implements a notifying mechanism, due to which they can notify to the pool that their task is completed and they are available to execute more tasks if in waiting queue