go-concurrency-patterns — detailed patterns and worked examples
Patterns
Pattern 1: Worker Pool
package main
import (
"context""fmt""sync"
)
type Job struct {
ID int
Data string
}
type Result struct {
JobID int
Output string
Err error
}
funcWorkerPool(ctx context.Context, numWorkers int, jobs <-chan Job) <-chan Result {
results := make(chan Result, len(jobs))
var wg sync.WaitGroup
for i := 0; i < numWorkers; i++ {
wg.Add(1)
gofunc(workerID int) {
defer wg.Done()
for job := range jobs {
select {
case <-ctx.Done():
returndefault:
result := processJob(job)
results <- result
}
}
}(i)
}
gofunc() {
wg.Wait()
close(results)
}()
return results
}
funcprocessJob(job Job) Result {
// Simulate workreturn Result{
JobID: job.ID,
Output: fmt.Sprintf("Processed: %s", job.Data),
}
}
// Usagefuncmain() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
jobs := make(chan Job, 100)
// Send jobsgofunc() {
for i := 0; i < 50; i++ {
jobs <- Job{ID: i, Data: fmt.Sprintf("job-%d", i)}
}
close(jobs)
}()
// Process with 5 workers
results := WorkerPool(ctx, 5, jobs)
for result := range results {
fmt.Printf("Result: %+v\n", result)
}
}
Pattern 2: Fan-Out/Fan-In Pipeline
package main
import (
"context""sync"
)
// Stage 1: Generate numbersfuncgenerate(ctx context.Context, nums ...int) <-chanint {
out := make(chanint)
gofunc() {
deferclose(out)
for _, n := range nums {
select {
case <-ctx.Done():
returncase out <- n:
}
}
}()
return out
}
// Stage 2: Square numbers (can run multiple instances)funcsquare(ctx context.Context, in <-chanint) <-chanint {
out := make(chanint)
gofunc() {
deferclose(out)
for n := range in {
select {
case <-ctx.Done():
returncase out <- n * n:
}
}
}()
return out
}
// Fan-in: Merge multiple channels into onefuncmerge(ctx context.Context, cs ...<-chanint) <-chanint {
var wg sync.WaitGroup
out := make(chanint)
// Start output goroutine for each input channel
output := func(c <-chanint) {
defer wg.Done()
for n := range c {
select {
case <-ctx.Done():
returncase out <- n:
}
}
}
wg.Add(len(cs))
for _, c := range cs {
go output(c)
}
// Close out after all inputs are donegofunc() {
wg.Wait()
close(out)
}()
return out
}
funcmain() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Generate input
in := generate(ctx, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// Fan out to multiple squarers
c1 := square(ctx, in)
c2 := square(ctx, in)
c3 := square(ctx, in)
// Fan in resultsfor result := range merge(ctx, c1, c2, c3) {
fmt.Println(result)
}
}