Effective Concurrency Patterns in Go

By Robert F1 min readFebruary 21, 2026

Concurrency in Go is achieved through goroutines, which are lightweight threads managed by the Go runtime. Channels are used for communication between goroutines, making it easier to share data safely. Understanding and implementing effective concurrency patterns can significantly enhance the performance and maintainability of your Go applications.

Goroutines and Channels

Goroutines

A goroutine is a function that executes concurrently with other functions. You can start a goroutine by using the go keyword followed by a function call.

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine!")
}

func main() {
    go sayHello() // Start a new goroutine
    time.Sleep(1 * time.Second) // Wait for goroutine to finish
}

Channels

Channels provide a way for goroutines to communicate with each other. You can create a channel using the make function and send/receive values using the <- operator.

package main

import (
    "fmt"
)

func greet(ch chan string) {
    ch <- "Hello from goroutine!"
}

func main() {
    ch := make(chan string)
    go greet(ch) // Start a new goroutine
    message := <-ch // Receive message from channel
    fmt.Println(message)
}

Common Concurrency Patterns

1. Worker Pool Pattern

The worker pool pattern is useful for managing a fixed number of goroutines that handle tasks from a shared queue. This pattern helps to limit resource usage and improve performance.

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
    }
}

func main() {
    const numWorkers = 3
    jobs := make(chan int, 10)
    var wg sync.WaitGroup

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

    // Send jobs to workers
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs) // Close the jobs channel

    wg.Wait() // Wait for all workers to finish
}

2. Fan-Out, Fan-In Pattern

This pattern is useful when you want to distribute work among multiple goroutines and then consolidate the results. It allows for efficient handling of multiple tasks concurrently.

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        results <- job * 2 // Example processing
    }
}

func main() {
    jobs := make(chan int, 10)
    results := make(chan int, 10)
    var wg sync.WaitGroup

    // Start workers
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // Send jobs
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs) // Close jobs channel

    go func() {
        wg.Wait()
        close(results) // Close results channel when done
    }()

    // Collect results
    for result := range results {
        fmt.Printf("Result: %d\n", result)
    }
}

3. Select Statement

The select statement provides a way to wait on multiple channel operations. It is particularly useful for handling timeouts and multiple goroutine communications.

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    time.Sleep(time.Second)
    ch <- fmt.Sprintf("Worker %d done", id)
}

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go worker(1, ch1)
    go worker(2, ch2)

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        }
    }
}

Best Practices for Concurrency in Go

Practice	Description
Use goroutines for I/O	Offload blocking I/O operations to goroutines to keep the main thread responsive.
Handle channel closure	Always close channels when done to prevent goroutines from leaking.
Use sync.WaitGroup	Use `sync.WaitGroup` to wait for a collection of goroutines to finish.
Limit goroutine creation	Avoid creating too many goroutines; use worker pools to manage concurrency.
Use context for cancellation	Utilize `context` package for managing cancellation and timeouts.

Conclusion

Understanding and effectively using concurrency patterns in Go is essential for building scalable and efficient applications. By leveraging goroutines and channels, developers can create responsive systems that make the most of available resources. The patterns discussed in this tutorial, such as worker pools, fan-out/fan-in, and the select statement, provide a solid foundation for handling concurrency in Go.

Learn more with useful resources: