Go: What is the difference between mutex and RWMutex?

Mutex — exclusive lock for mutual exclusion. RWMutex — read-write lock allowing concurrent reads but exclusive writes.

sync.Mutex:

• Lock()/Unlock() for all operations.
• Only one goroutine at a time.
• Lower overhead (~20ns per operation).
• Simple to use.

sync.RWMutex:

• RLock()/RUnlock() for reads (concurrent).
• Lock()/Unlock() for writes (exclusive).
• Higher overhead (~30-40ns per operation).
• Better for read-heavy workloads.

1// RWMutex for config store
2type ConfigStore struct {
3    mu      sync.RWMutex
4    configs map[string]string
5}
6
7func (s *ConfigStore) Get(key string) (string, bool) {
8    s.mu.RLock()
9    defer s.mu.RUnlock()
10    val, ok := s.configs[key]
11    return val, ok
12}
13
14func (s *ConfigStore) Set(key, value string) {
15    s.mu.Lock()
16    defer s.mu.Unlock()
17    s.configs[key] = value
18}

When to use RWMutex:

• Read-heavy workloads (caches, config).
• Read:write ratio > 10:1.
• Concurrent read access critical.

When to use Mutex:

• Write-heavy workloads.
• Simple cases (counters).
• When RWMutex overhead isn't justified.

Common mistakes:

• Using RWMutex for write-heavy work.
• Copying mutex after first use.
• Forgetting defer Unlock().
• Not benchmarking to confirm performance.
• Using RWMutex for single-goroutine scenarios.