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:

• Single lock for all operations.
• Lock() blocks all other goroutines.
• Unlock() releases the lock.
• Overhead: ~20ns per lock/unlock.
• Use when writes are frequent or operations are short.

sync.RWMutex:

• RLock()/RUnlock() — multiple readers allowed concurrently.
• Lock()/Unlock() — exclusive write access.
• Read operations don't block each other.
• Write operations block all readers and other writers.
• Overhead: ~30-40ns per lock/unlock (higher than Mutex).

Performance comparison:

1// Mutex — good for write-heavy
2var mu sync.Mutex
3func update(data int) {
4    mu.Lock()
5    defer mu.Unlock()
6    sharedData = data
7}
8
9// RWMutex — good for read-heavy
10var rwmu sync.RWMutex
11func read() int {
12    rwmu.RLock()
13    defer rwmu.RUnlock()
14    return sharedData
15}
16func write(data int) {
17    rwmu.Lock()
18    defer rwmu.Unlock()
19    sharedData = data
20}

When to use RWMutex:

• Cache implementations (many reads, rare updates).
• Configuration stores.
• Connection pools.
• Any read:write ratio > 10:1.

When to use Mutex:

• Write-heavy workloads.
• Simple counters or flags.
• When RWMutex overhead isn't justified.

Common mistakes:

• Using RWMutex for write-heavy work (overhead wasted).
• Copying mutex after first use (causes undefined behavior).
• Forgetting defer mu.Unlock() (deadlock on panic).
• Using RWMutex for single-goroutine scenarios (unnecessary overhead).
• Not checking if RWMutex is actually faster in your specific workload (benchmark it).