Go: What is the difference between mutex and RWMutex?

Mutex — exclusive lock (one goroutine at a time). RWMutex — read-write lock (multiple readers OR one writer).

sync.Mutex:

• Lock() — acquires exclusive access.
• Unlock() — releases the lock.
• All operations (read/write) go through same lock.
• Simple, low overhead (~20ns).

sync.RWMutex:

• RLock()/RUnlock() — shared read access.
• Lock()/Unlock() — exclusive write access.
• Readers don't block each other.
• Writers block all readers and writers.
• Higher overhead per operation (~30-40ns).

1// Thread-safe cache with RWMutex
2type Cache struct {
3    mu   sync.RWMutex
4    data map[string]interface{}
5}
6
7func (c *Cache) Get(key string) (interface{}, bool) {
8    c.mu.RLock()
9    defer c.mu.RUnlock()
10    val, ok := c.data[key]
11    return val, ok
12}
13
14func (c *Cache) Set(key string, value interface{}) {
15    c.mu.Lock()
16    defer c.mu.Unlock()
17    c.data[key] = value
18}

When to use RWMutex:

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

When to use Mutex:

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

Common mistakes:

• Using RWMutex for write-heavy work (wasted overhead).
• Copying mutex after first use (undefined behavior).
• Forgetting defer Unlock() (deadlock on panic).
• Not benchmarking to confirm RWMutex is faster.
• Using RWMutex for single-goroutine scenarios.