Worker Pool implementation for Goroutines, the name comes from the fusion of the words Worker and Pool. This implementation is based in the code released by Naveen Ramanathan in the Buffered Channels and Worker Pools article. I liked the snipped and I thought it was an excellent base to convert it into a module. This project may have sporadic updates as I need new features.
Install wool:
$ go get github.com/otzarri/wool
Import wool into your program and use it. The example below shows how to create a very simple concurrent application. The jobFunc
and resfunc
functions must be externally implemented to allow wool
to execute custom code.
$ mkdir app
$ cd app
$ vim app.go
package main
import (
"fmt"
"strconv"
"github.com/otzarri/wool"
)
// jobFunc is a function implementation expected by `wool`. When a new job is
// allocated, `wool` sends the job to `jobFunc`, where it is expected to be an
// implementation to process the job and return a result. The result will be
// received by `wool` and if `Job.Active` field is `false`, it will be discarded.
// Otherwise, the result will be directed to the function `resFunc`.
func jobFunc(job wool.Job) wool.Result {
values := map[string]string{}
number, err := strconv.Atoi(job.Values["number"])
if err != nil {
job.Active = false
}
if number%2 == 0 {
values["type"] = "even"
} else {
values["type"] = "odd"
}
return wool.Result{Job: job, Values: values}
}
// resFunc is a function implementation expected by `wool`. When a new result is
// returned from `jobFunc`, `wool` sends the result to `resFunc`, where it is
// expected to be an implementation to process the result and return a it. The
// result will be received by `wool` and if `Result.Job.Active` field is
// `false`, it will be discarded. Otherwise, the result will be added to the
// result list returned by the function `wool.Work`, executed into `main()`.
func resFunc(result wool.Result) wool.Result {
if result.Values["type"] == "odd" {
result.Job.Active = false
}
return result
}
func main() {
workers := 10
minNum := 0
maxNum := 99
jobValueMapList := []map[string]string{}
for i := minNum; i < maxNum; i++ {
jobValueMapList = append(jobValueMapList, map[string]string{"number": strconv.Itoa(i)})
}
jobResultList := wool.Work(workers, jobValueMapList, jobFunc, resFunc)
fmt.Printf("The even numbers between %d and %d are: ", minNum, maxNum)
for _, result := range jobResultList {
number := result.Job.Values["number"]
fmt.Printf("%s ", number)
}
fmt.Println()
}
$ go mod init app
$ go mod tidy
$ go run app.go
The even numbers between 0 and 99 are: 0 2 4 6 8 10 20 22 24 26 12 14 18 28 30 32 34 16 36 38 40 42 44 46 48 50 52 54 56 58 60 62 74 76 78 80 82 84 64 66 68 70 72 86 88 90 92 94 96 9
⭐ If you want to see wool
working into a program, you can take a look at the otzarri/nscan project.
Run tests as usual in Go:
$ go test -v ./...
Run coverage tests:
$ go test -v -coverprofile=coverage.out ./...
$ go tool cover -html=coverage.out