7.6 Putting It Together | Concurrency Patterns | Infrastructure Development with Go

Production worker pool with context, rate limiting, and clean shutdown:

2 · Worked example — read every step

func processQueue(ctx context.Context, jobs <-chan Job, workers int, ratePerSec int) <-chan Result {
    results := make(chan Result)
    limiter := time.NewTicker(time.Second / time.Duration(ratePerSec))

    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                select {
                case <-ctx.Done():
                    return
                case job, ok := <-jobs:
                    if !ok {
                        return // jobs channel closed
                    }
                    <-limiter.C // rate limit
                    results <- processJob(job)
                }
            }
        }()
    }

    go func() {
        wg.Wait()
        limiter.Stop()
        close(results)
    }()

    return results
}

This combines everything: bounded workers, rate limiting, context cancellation, and clean channel lifecycle.

3 · Fill the gaps

The worker's inner loop, from memory — two ways out, one throttle.

for {
    select {
    case <-ctx.Done():
        return
    case job,  := <-jobs:
        if  {
            return // no more work coming
        }
        
        results <- processJob(job)
    }
}

Next: the Build section — ship the reporter. Second repo of five.