Stop reading code.
Start producing it.

package main

import (
    "fmt"
    "sync"
)

func parallelSum(numbers []int, workers int) int {
    if len(numbers) == 0 {
        return 0
    }
    if workers < 1 {
        workers = 1
    }
    if workers > len(numbers) {
        workers = len(numbers)
    }

    partials := make(chan int, workers)
    chunkSize := (len(numbers) + workers - 1) / workers
    var wg sync.WaitGroup

    for start := 0; start < len(numbers); start += chunkSize {
        end := min(start+chunkSize, len(numbers))
        chunk := numbers[start:end]
        wg.Go(func() {
            sum := 0
            for _, number := range chunk {
                sum += number
            }
            partials <- sum
        })
    }

    wg.Wait()
    close(partials)

    total := 0
    for partial := range partials {
        total += partial
    }
    return total
}

func main() {
    fmt.Println(parallelSum([]int{1, 2, 3, 4, 5, 6, 7, 8}, 3))
}

Each worker owns one read-only slice window and one local sum. The buffer is large enough for every partial, so waiting before ranging cannot deadlock. The coordinator closes only after every sender returns.

Runnable source · WaitGroup docs

package main

import (
    "fmt"
    "strings"
    "sync"
)

func parallelWordCount(texts []string) map[string]int {
    partials := make(chan map[string]int, len(texts))
    var wg sync.WaitGroup

    for _, text := range texts {
        text := text
        wg.Go(func() {
            local := make(map[string]int)
            for _, word := range strings.Fields(text) {
                local[word]++
            }
            partials <- local
        })
    }

    wg.Wait()
    close(partials)

    total := make(map[string]int)
    for partial := range partials {
        for word, count := range partial {
            total[word] += count
        }
    }
    return total
}

func main() {
    counts := parallelWordCount([]string{
        "go channels go",
        "mutex channels",
        "go waitgroup",
    })
    fmt.Println(counts["go"], counts["channels"], counts["mutex"])
}

This is reduce-by-ownership: workers mutate only private maps, then the caller serially merges them. It avoids a hot shared lock and makes the race-free boundary visible in the types and channel flow.

Runnable source · Go maps in action — concurrency

package main

import (
    "fmt"
    "sync"
)

type Job struct {
    ID    int
    Value int
}

type Result struct {
    ID    int
    Value int
}

func runPool(input []int, workerCount int) []int {
    if workerCount < 1 {
        workerCount = 1
    }

    jobs := make(chan Job)
    results := make(chan Result)
    var workers sync.WaitGroup

    for range workerCount {
        workers.Go(func() {
            for job := range jobs {
                results <- Result{
                    ID:    job.ID,
                    Value: job.Value * job.Value,
                }
            }
        })
    }

    go func() {
        defer close(jobs)
        for id, value := range input {
            jobs <- Job{ID: id, Value: value}
        }
    }()

    go func() {
        workers.Wait()
        close(results)
    }()

    output := make([]int, len(input))
    for result := range results {
        output[result.ID] = result.Value
    }
    return output
}

func main() {
    fmt.Println(runPool([]int{2, 3, 4, 5}, 3))
}

IDs separate completion order from output order. The producer owns jobs; a coordinator that observes all senders owns results. The caller drains results concurrently with the workers, avoiding a circular wait.

Runnable source · Go concurrency patterns — pipelines

package main

import (
    "fmt"
    "sync"
)

func mapLimit(input []int, limit int, transform func(int) int) []int {
    if limit < 1 {
        limit = 1
    }

    output := make([]int, len(input))
    slots := make(chan struct{}, limit)
    var wg sync.WaitGroup

    for index, value := range input {
        index, value := index, value
        wg.Go(func() {
            slots <- struct{}{}
            defer func() { <-slots }()

            output[index] = transform(value)
        })
    }

    wg.Wait()
    return output
}

func main() {
    doubled := mapLimit([]int{1, 2, 3, 4, 5}, 2, func(n int) int {
        return n * 2
    })
    fmt.Println(doubled)
}

Each token occupies one buffer slot, so capacity is the maximum active count. Each goroutine writes a distinct slice element, and Wait completes before the caller reads the slice. This bounds active work, though it still creates one goroutine per input.

Runnable source · memory model — buffered channels

package main

import (
    "fmt"
    "sync"
)

type Ledger struct {
    mu       sync.Mutex
    balances map[string]int
}

func NewLedger(initial map[string]int) *Ledger {
    balances := make(map[string]int, len(initial))
    for account, balance := range initial {
        balances[account] = balance
    }
    return &Ledger{balances: balances}
}

func (l *Ledger) Transfer(from, to string, amount int) bool {
    if amount <= 0 {
        return false
    }

    l.mu.Lock()
    defer l.mu.Unlock()

    if l.balances[from] < amount {
        return false
    }
    l.balances[from] -= amount
    l.balances[to] += amount
    return true
}

func (l *Ledger) Snapshot() map[string]int {
    l.mu.Lock()
    defer l.mu.Unlock()

    copyOfBalances := make(map[string]int, len(l.balances))
    for account, balance := range l.balances {
        copyOfBalances[account] = balance
    }
    return copyOfBalances
}

func main() {
    ledger := NewLedger(map[string]int{"a": 100, "b": 100})
    var wg sync.WaitGroup

    for range 100 {
        wg.Go(func() {
            ledger.Transfer("a", "b", 1)
        })
        wg.Go(func() {
            ledger.Transfer("b", "a", 1)
        })
    }

    wg.Wait()
    balances := ledger.Snapshot()
    fmt.Println(balances["a"], balances["b"], balances["a"]+balances["b"])
}

The lock protects an invariant, not merely a map operation: checking funds and changing both balances form one critical section. Defensive copies prevent callers from bypassing that lock through a shared map reference.

Runnable source · Mutex documentation