Go Concurrency Best Practices

By Alessandro D.P.1 min readFebruary 16, 2026

Understanding Goroutines and Channels

Goroutines are lightweight threads managed by the Go runtime, while channels provide a way for goroutines to communicate with each other. Proper use of these features is essential for effective concurrency.

Best Practice 1: Use Goroutines Wisely

Goroutines are cheap to create, but spawning too many can lead to resource exhaustion. Here’s how to manage goroutines effectively:

Limit the Number of Concurrent Goroutines: Use a worker pool pattern to control the number of goroutines running simultaneously.

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    // Simulate work
    // time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    const numWorkers = 5
    var wg sync.WaitGroup

    for i := 1; i <= numWorkers; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}

Best Practice 2: Use Channels for Communication

Channels are the idiomatic way of communicating between goroutines. They help ensure that data is safely shared without explicit locks.

Selectively Use Buffered Channels: Buffered channels can help avoid blocking but should be used judiciously to prevent unexpected behavior.

package main

import (
    "fmt"
    "time"
)

func main() {
    messages := make(chan string, 2)

    messages <- "Hello"
    messages <- "World"

    close(messages)

    for msg := range messages {
        fmt.Println(msg)
    }
}

Best Practice 3: Avoid Shared State

When possible, avoid sharing state between goroutines. If shared state is necessary, use synchronization primitives like mutexes.

Use Mutexes for Shared State: The sync.Mutex type can protect shared data from concurrent access.

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mu      sync.Mutex
)

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    const numGoroutines = 100
    var wg sync.WaitGroup

    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

Managing Goroutine Lifecycles

Properly managing the lifecycle of goroutines is crucial to prevent memory leaks and ensure graceful shutdowns.

Best Practice 4: Use Context for Cancellation

The context package provides a way to manage cancellation signals across goroutines. This is particularly useful in long-running operations.

package main

import (
    "context"
    "fmt"
    "time"
)

func doWork(ctx context.Context) {
    select {
    case <-time.After(2 * time.Second):
        fmt.Println("Work completed")
    case <-ctx.Done():
        fmt.Println("Work canceled")
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go doWork(ctx)

    // Simulate some work
    time.Sleep(1 * time.Second)
    cancel() // Cancel the work

    // Wait a moment to see the result
    time.Sleep(1 * time.Second)
}

Best Practice 5: Handle Timeouts

Using timeouts can prevent goroutines from running indefinitely. The context package also allows you to set timeouts.

package main

import (
    "context"
    "fmt"
    "time"
)

func doWork(ctx context.Context) {
    select {
    case <-time.After(3 * time.Second):
        fmt.Println("Work completed")
    case <-ctx.Done():
        fmt.Println("Work canceled due to timeout")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    go doWork(ctx)

    // Wait for the work to complete or timeout
    time.Sleep(4 * time.Second)
}

Summary of Best Practices

Best Practice	Description
Use Goroutines Wisely	Limit the number of concurrent goroutines with worker pools.
Use Channels for Communication	Utilize channels for safe data sharing between goroutines.
Avoid Shared State	Prefer goroutines to avoid shared state; use mutexes when needed.
Use Context for Cancellation	Manage cancellation signals with the `context` package.
Handle Timeouts	Prevent indefinite execution with timeouts using `context`.

By following these best practices, you can leverage Go's concurrency model effectively, resulting in applications that are not only efficient but also easier to maintain and debug.