GF
Go Foundation API
worker API

worker

package

API reference for the worker package.

Imports

(2)
STD context STD sync
T
type

Task

Task is a work function executed by the pool.

pkg/worker/worker.go:9-9 
type Task func(context.Context) error
S
struct

Future

Future holds the result of an asynchronous task.

pkg/worker/worker.go:12-14 
type Future struct

Methods

Wait
Method

Returns

error 
func (*Future) Wait() error
{
	r := <-f.ch
	return r.Err
}

Fields

Name Type Description
ch chan Result
S
struct

Result

Result holds the outcome of a completed Task.

pkg/worker/worker.go:17-19 
type Result struct

Fields

Name Type Description
Err error
S
struct

Pool

Pool is a fixed-size worker pool for concurrent task execution.

pkg/worker/worker.go:27-34 
type Pool struct

Methods

worker
Method

worker pulls tasks from the tasks channel until done is closed. 

func (*Pool) worker()
{
	defer p.wg.Done()
	for {
		select {
		case task := <-p.tasks:
			_ = task(p.ctx)
		case <-p.done:
			return
		}
	}
}
Submit
Method

Submit enqueues a task for execution. Returns false if the pool is shut down or shutting down; the task is not executed in that case.

Parameters

task Task

Returns

bool 
func (*Pool) Submit(task Task) bool
{
	select {
	case p.tasks <- task:
		return true
	case <-p.done:
		return false
	}
}
Shutdown
Method

Shutdown stops accepting new tasks and waits for in-progress work to finish. The task channel is unbuffered, so no tasks can be pending pickup when done is closed; any Submit in progress will observe done and return false. 

func (*Pool) Shutdown()
{
	p.once.Do(func() {
		close(p.done)
		p.wg.Wait()
		p.cancel()
	})
}

Fields

Name Type Description
wg sync.WaitGroup
tasks chan Task
done chan struct{}
cancel context.CancelFunc
ctx context.Context
once sync.Once
F
function

NewPool

NewPool creates a fixed-size worker pool of n goroutines.

Parameters

n
int

Returns

*Pool
pkg/worker/worker.go:45-62 
func NewPool(n int) *Pool

{
	if n <= 0 {
		n = 1
	}

	ctx, cancel := context.WithCancel(context.Background())
	p := &Pool{
		tasks:  make(chan Task),
		done:   make(chan struct{}),
		cancel: cancel,
		ctx:    ctx,
	}
	for i := 0; i < n; i++ {
		p.wg.Add(1)
		go p.worker()
	}
	return p
}

Example 

pool := worker.NewPool(4)
defer pool.Shutdown()
pool.Submit(func(ctx context.Context) error {
	return doWork(ctx)
})