Module 3 · Exercise 2 · ~40 min · Real Go code

Context-Aware Worker Pool

Build a bounded-concurrency worker pool with proper context handling and first-error-wins propagation. The same shape as errgroup.Group in the wild — and the shape you'll use for parallel command submission, parallel queries, parallel anything.

cd module-03-concurrency/exercises/exercise-02-worker-pool
go test -v -race ./...

The signature

err := workerpool.Run(ctx, workers, tasks)

That's the whole API. Underneath, the pool must:

• Run at most workers tasks concurrently.
• If any task returns an error, cancel all remaining work and return that error.
• If ctx is canceled externally, propagate that cancellation to running tasks (via their ctx argument) and stop dispatching new ones.
• Never leak goroutines.

Tactical hints

• Make a derived ctx with context.WithCancel. Pass it to tasks and cancel it on first error.
• Buffered channel of size 1 to receive errors; select { case errCh <- err: default: } captures the first and drops the rest non-blockingly.
• Use a sync.WaitGroup to know when workers finish.
• The "send tasks to a channel, workers for-range it" pattern from Module 3 Lesson 1 is exactly the shape here.

Why this is THE pattern

Real Canton-adjacent code does this everywhere — submitting a batch of commands in parallel, fetching state for many parties concurrently, processing a transaction-stream window. Once you've written this once, the production version (with metrics, with retries) is a small extension of the same shape.

The standard library's golang.org/x/sync/errgroup is essentially this — go read its source after passing tests.