Goroutine not updating map correctly in concurrent Go program

Question

I’m trying to update a map from multiple goroutines, but the results seem inconsistent. Sometimes keys are missing or values are wrong.

Here’s my code: package main

import (
    "fmt"
    "sync"
)

func main() {
    counter := make(map[string]int)
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", id)
            counter[key] = id * 10
        }(i)
    }

    wg.Wait()
    fmt.Println(counter)
}

Sometimes the output is missing some keys or has incorrect values.

I tried adding time.Sleep() inside the goroutine, but that doesn’t fix it reliably.

Map (nor any value in Go) is not safe for concurrent read/write. Don't do that. You should expect nothing from your code without proper synchronization. — icza
– icza, Commented Oct 29 at 12:53
Sleep is not a synchronization primitive. You must always synchronize concurrent reads and writes. — Mr_Pink
– Mr_Pink, Commented Oct 29 at 13:39
It looks like that you thought that synchronizing the main goroutines with the ones spawned in the loop is enough (fmt.Println is guaranteed to be called after all the goroutines finish) but it is not because the goroutines spawned in the loop are executed concurrently with each other, and they all mutate the map. So should you run your example after building it with go build -race, you would see the Go runtime crash your program almost immediately, reporting a data race. Go has no concurrency-safe builtin types, and most 3rd-party types are not concurrency-safe either, unless documented. — kostix
– kostix, Commented Oct 29 at 15:31

Brian Wagner · Accepted Answer · 2025-10-29 14:28:09Z

As said above, maps are not safe inside go routines like this.

The simplest way to modify your example is to add a mutex and perform lock/unlock on each pass.

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    m  map[string]int
    mu sync.Mutex
}

func main() {
    counter := Counter{m: make(map[string]int)}
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", id)

            counter.mu.Lock()
            defer counter.mu.Unlock()
            counter.m[key] = id * 10
        }(i)
    }

    wg.Wait()
    fmt.Println(counter.m)
}

This should help demonstrate the issue. But there are other ways to handle this, with read/write mutex or a channel. Note that using locks may slow down the program, compared to other methods.

More discussion: How safe are Golang maps for concurrent Read/Write operations?

Collectives™ on Stack Overflow

Goroutine not updating map correctly in concurrent Go program

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related