Maps and Concurrency in Go: Safe Practices and Pitfalls

Managing concurrency is one of Go’s powerful features, and using maps safely within concurrent programs is a valuable skill for any Go developer. Maps are not safe for concurrent use by default, which means when multiple goroutines access a map simultaneously, without adequate synchronization, it can lead to unexpected behavior or even panic. This article explores the best practices for using maps with concurrency in Go, along with some common pitfalls.

Understanding Maps in Go

Maps in Go are a built-in data structure that associates keys with values. These are very handy for organizing data, but require care when used in concurrent settings. Here’s how you define a basic map in Go:

package main

import "fmt"

func main() {
    // Creating a map
    personAge := map[string]int{
        "Alice": 30,
        "Bob": 25,
    }

    // Accessing value
    fmt.Println("Alice's age:", personAge["Alice"])
}

Basic Concurrency in Go

Go provides goroutines for concurrency, which allows functions to run separately from other processes:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(500 * time.Millisecond)
    }
}

func main() {
    go printNumbers()
    fmt.Println("Printing numbers asynchronously")
    time.Sleep(3 * time.Second)
}

Maps and Concurrency: An Unsafe Practice

Since maps in Go are not inherently safe for concurrent use, attempting to have multiple goroutines write to a map without proper synchronization will result in a panic:

package main

func main() {
    myMap := make(map[int]int)

    for i := 0; i < 100; i++ {
        go func(val int) {
            myMap[val] = val * 2 // Writing to the map concurrently
        }(i)
    }
}

// Running this code may cause a panic due to concurrent map writes.

Safe Practices with sync.Mutex

sync.Mutex can be used to ensure safe access to a map by locking it during read and write operations:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    myMap := make(map[int]int)

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(val int) {
            mu.Lock()
            myMap[val] = val * 2
            mu.Unlock() // Unlock after writing to prevent deadlock
            wg.Done()
        }(i)
    }

    wg.Wait() // Wait for all goroutines to finish
    fmt.Println("Map population complete")
}