Popularity
1.7
Stable
Activity
0.0
Stable
13
3
1

Programming language: Go
License: MIT License
Tags: Goroutines    

gohive alternatives and similar packages

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

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