Concurrency & Channels

Go Concurrent Worker Pool with Channels

Dispatch jobs across a pool of concurrent goroutine workers using buffered channels and sync.WaitGroup coordination.

Go Source Code

Editable code sample with line numbers

package main

import (
	"fmt"
	"sync"
	"time"
)

// Task represents a unit of work
type Task struct {
	ID    int
	Value int
}

// Result represents the processed output
type Result struct {
	TaskID int
	Square int
}

func worker(id int, jobs <-chan Task, results chan<- Result, wg *sync.WaitGroup) {
	defer wg.Done()
	for job := range jobs {
		// Simulate processing computation
		res := Result{
			TaskID: job.ID,
			Square: job.Value * job.Value,
		}
		results <- res
	}
}

func main() {
	const numJobs = 6
	const numWorkers = 3

jobs := make(chan Task, numJobs)
	results := make(chan Result, numJobs)
	var wg sync.WaitGroup

// Launch worker pool
	for w := 1; w <= numWorkers; w++ {
		wg.Add(1)
		go worker(w, jobs, results, &wg)
	}

// Enqueue tasks
	for j := 1; j <= numJobs; j++ {
		jobs <- Task{ID: j, Value: j * 10}
	}
	close(jobs) // Signal workers that no more jobs will be sent

// Wait for all workers to finish in background and close results
	go func() {
		wg.Wait()
		close(results)
	}()

fmt.Printf("Processed %d tasks using %d concurrent Go workers:\n", numJobs, numWorkers)
	for res := range results {
		fmt.Printf("  Task #%d -> Result: %d\n", res.TaskID, res.Square)
	}
}

Expected Output

When this program is compiled and executed, the terminal outputs:

Processed 6 tasks using 3 concurrent Go workers:
  Task #1 -> Result: 100
  Task #2 -> Result: 400
  Task #3 -> Result: 900
  Task #4 -> Result: 1600
  Task #5 -> Result: 2500
  Task #6 -> Result: 3600

How the Code Works

Worker pools prevent unbounded goroutine creation by funneling jobs through a buffered channel to a fixed number of worker goroutines. sync.WaitGroup coordinates graceful pipeline shutdown.

Time Complexity

O(N / NumWorkers)

Space Complexity

O(NumJobs) channel buffer

Key Takeaways & Best Practices

Buffered channels decouple producer and consumer execution throughput.
sync.WaitGroup guarantees all goroutines finish execution before program exit.

Master Go with ZenCompiler

Practice in our high-performance cloud container IDE with multi-file support, interactive terminal STDIN, real-time memory visualizer, and structured lessons.

Related Go Examples

Concurrency & Networking

O(N * Interval)

Go Rate Limiter with time.Ticker

Implement a token bucket request rate limiter in Go using time.Ticker and non-blocking channel selects.

Runnable Code

View Code

Concurrency & Systems

O(N / Workers)

Go Worker Pool Concurrency with Goroutines and Channels

Implement a concurrent worker pool pattern in Go using goroutines, buffered channels, and sync.WaitGroup to process tasks concurrently.

Go Program to Reverse UTF-8 String (Runes)

Reverse strings safely in Go by converting to []rune to handle multi-byte Unicode characters correctly without slicing bytes.

Runnable Code

View Code

Processed 6 tasks using 3 concurrent Go workers: Task #1 -> Result: 100 Task #2 -> Result: 400 Task #3 -> Result: 900 Task #4 -> Result: 1600 Task #5 -> Result: 2500 Task #6 -> Result: 3600

How the Code Works

Worker pools prevent unbounded goroutine creation by funneling jobs through a buffered channel to a fixed number of worker goroutines. sync.WaitGroup coordinates graceful pipeline shutdown.

Time Complexity

O(N / NumWorkers)

Space Complexity

O(NumJobs) channel buffer

Key Takeaways & Best Practices

Buffered channels decouple producer and consumer execution throughput.
sync.WaitGroup guarantees all goroutines finish execution before program exit.

Go Concurrent Worker Pool with Channels

Go Source Code

Expected Output

How the Code Works

Key Takeaways & Best Practices

Master Go with ZenCompiler

Related Go Examples

Go Rate Limiter with time.Ticker

Go Worker Pool Concurrency with Goroutines and Channels

Go Program to Reverse UTF-8 String (Runes)

Platform & Tools

Account

Company & Help

Legal & Policies

Go Concurrent Worker Pool with Channels

Go Source Code

Expected Output

How the Code Works

Key Takeaways & Best Practices

Master Go with ZenCompiler

Related Go Examples

Go Rate Limiter with time.Ticker

Go Worker Pool Concurrency with Goroutines and Channels

Go Program to Reverse UTF-8 String (Runes)