README

Vardius - worker-pool

Build Status Go Report Card codecov license

Go simple async worker pool.

ABOUT

Contributors:

Want to contribute ? Feel free to send pull requests!

Have problems, bugs, feature ideas? We are using the github issue tracker to manage them.

HOW TO USE

  1. GoDoc

Benchmark

CPU: 3,3 GHz Intel Core i7

RAM: 16 GB 2133 MHz LPDDR3

➜  worker-pool git:(master) ✗ go test -bench=. -cpu=4 -benchmem
goos: darwin
goarch: amd64
BenchmarkWorker1-4                	 3000000	       453 ns/op	      56 B/op	       3 allocs/op
BenchmarkWorker1Parallel-4        	 3000000	       506 ns/op	      48 B/op	       2 allocs/op
BenchmarkWorker100-4              	 3000000	       485 ns/op	      56 B/op	       3 allocs/op
BenchmarkWorker100Parallel-4      	 3000000	       444 ns/op	      48 B/op	       2 allocs/op
BenchmarkWorkerNumCPU-4           	 3000000	       467 ns/op	      56 B/op	       3 allocs/op
BenchmarkWorkerNumCPUParallel-4   	 3000000	       431 ns/op	      48 B/op	       2 allocs/op
PASS
ok  	worker-pool	11.570s

Basic example

package main

import (
    "fmt"
    "sync"

    "github.com/vardius/worker-pool"
)

func main() {
	var wg sync.WaitGroup

	poolSize := 1
	jobsAmount := 3
	workersAmount := 2

	// create new pool
	pool := workerpool.New(poolSize)
	out := make(chan int, jobsAmount)

	pool.Start(workersAmount, func(i int) {
		defer wg.Done()
		out <- i
	})

	wg.Add(jobsAmount)

	for i := 0; i < jobsAmount; i++ {
		pool.Delegate(i)
	}

	go func() {
		// stop all workers after jobs are done
		wg.Wait()
		close(out)
		pool.Stop()
	}()

	sum := 0
	for n := range out {
		sum += n
	}

	fmt.Println(sum)
	// Output:
	// 3
}

License

This package is released under the MIT license. See the complete license in the package:

LICENSE

Expand ▾ Collapse ▴

Documentation

Overview

    Package workerpool provides simple async workers

    Example
    Output:
    
    3
    
    Example (Second)
    Output:
    
    8
    
    Example (Third)
    Output:
    
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Pool

    type Pool interface {
    	// Delegate job to a workers
    	// will block if channel is full, you might want to wrap it with goroutine to avoid it
    	// will panic if called after Stop()
    	Delegate(args ...interface{})
    	// Start given number of workers that will take jobs from a queue
    	Start(maxWorkers int, fn interface{}) error
    	// Stop all workers
    	Stop()
    }

      Pool implements worker pool

      func New

      func New(queueLength int) Pool

        New creates new worker pool with a given job queue length

        Source Files