Design a worker pool for processing 100,000 jobs with back-pressure and graceful shutdown.

Question

Accepted Answer

type Job struct{ ID int; Payload []byte }
type Result struct{ JobID int; Output []byte; Err error }

type WorkerPool struct {
    jobs    chan Job
    results chan Result
    wg      sync.WaitGroup
}

func NewWorkerPool(numWorkers, queueSize int) *WorkerPool {
    p := &WorkerPool{
        jobs:    make(chan Job, queueSize), // back-pressure: sender blocks when full
        results: make(chan Result, queueSize),
    }
    for i := 0; i < numWorkers; i++ {
        p.wg.Add(1)
        go p.worker()
    }
    return p
}

func (p *WorkerPool) worker() {
    defer p.wg.Done()
    for job := range p.jobs { // exits when jobs channel is closed
        output, err := processJob(job)
        p.results <- Result{JobID: job.ID, Output: output, Err: err}
    }
}

func (p *WorkerPool) Submit(job Job) {
    p.jobs <- job // blocks if queue is full — natural back-pressure
}

func (p *WorkerPool) Shutdown() {
    close(p.jobs)   // signal workers: no more jobs
    p.wg.Wait()     // wait for in-progress jobs to complete
    close(p.results)
}

func main() {
    pool := NewWorkerPool(20, 500)

// Produce jobs in a separate goroutine
    go func() {
        for i := 0; i < 100_000; i++ {
            pool.Submit(Job{ID: i, Payload: []byte("data")})
        }
        pool.Shutdown()
    }()

// Consume results
    for result := range pool.results {
        if result.Err != nil {
            log.Printf("job %d failed: %v", result.JobID, result.Err)
        }
    }
} Buffer size controls back-pressure: smaller buffer = tighter back-pressure on producer Close the jobs channel to signal workers — ranging over a closed channel exits cleanly WaitGroup ensures all in-progress jobs complete before results channel is closed For context-aware cancellation, pass ctx to each worker and select on ctx.Done() Add a dead-letter queue or retry channel for failed jobs in production

Design a worker pool for processing 100,000 jobs with back-pressure and graceful shutdown.

A worker pool uses a buffered jobs channel for back-pressure, N goroutines as workers, a WaitGroup for tracking completion, and context cancellation for graceful shutdown.

Scenario Questions

Follow-up Questions