What is sync.Map vs regular map with Mutex?

Question

Accepted Answer

sync.Map and map+Mutex are two approaches to **thread-safe data storage**.

```go
// sync.Map: optimized for read-heavy scenarios
var m sync.Map

// Write
m.Store("key", "value")

// Read
val, ok := m.Load("key")
if ok {
    fmt.Println(val.(string))
}

// Atomic operation
actual, loaded := m.LoadOrStore("key", "default")

// Range (non-blocking)
m.Range(func(key, value interface{}) bool {
    fmt.Printf("%v: %v
", key, value)
    return true  // true = continue
})

// map + Mutex: general purpose
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]string
}

func (s *SafeMap) Get(key string) (string, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    val, ok := s.m[key]
    return val, ok
}

func (s *SafeMap) Set(key, value string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[key] = value
}

// Performance comparison
func BenchmarkSyncMapRead(b *testing.B) {
    var m sync.Map
    m.Store("key", "value")
    for i := 0; i < b.N; i++ {
        m.Load("key")
    }
}

func BenchmarkMutexMapRead(b *testing.B) {
    m := map[string]string{"key": "value"}
    var mu sync.RWMutex
    for i := 0; i < b.N; i++ {
        mu.RLock()
        _ = m["key"]
        mu.RUnlock()
    }
}
```

**When to use sync.Map:**
- read-heavy (many reads, few writes).
- Keys are stable (don't change often).

**When to use map+Mutex:**
- write-heavy (frequent writes).
- Need type safety (no interface{}).

Go: What is sync.Map vs regular map with Mutex?