Go: What is the difference between mutex and RWMutex?

Mutex — provides exclusive access (only one goroutine at a time). RWMutex — allows concurrent reads but exclusive writes.

sync.Mutex:

• Lock() acquires exclusive access.
• Unlock() releases the lock.
• Only one goroutine can hold the lock at any time.
• All operations (read or write) go through the same lock.

1var mu sync.Mutex
2
3func Read() {
4    mu.Lock()
5    defer mu.Unlock()
6    // Read shared data — exclusive access
7}
8
9func Write() {
10    mu.Lock()
11    defer mu.Unlock()
12    // Modify shared data — exclusive access
13}

sync.RWMutex:

• RLock() / RUnlock() — multiple goroutines can read simultaneously.
• Lock() / Unlock() — exclusive write access.
• Writers block all readers and other writers.
• Readers can read concurrently with other readers.

1var rwmu sync.RWMutex
2
3func Read() {
4    rwmu.RLock()
5    defer rwmu.RUnlock()
6    // Read shared data — multiple goroutines can read
7}
8
9func Write() {
10    rwmu.Lock()
11    defer rwmu.Unlock()
12    // Modify shared data — exclusive access
13}

When to use RWMutex:

• Read-heavy workloads (e.g., caching, configuration stores).
• Many readers, few writers.
• When read operations are much more frequent than writes.

When to use Mutex:

• Write-heavy workloads.
• Simple use cases where RWMutex overhead isn't justified.
• When you need mutual exclusion for both reads and writes.

Common mistakes:

• Using RWMutex for write-heavy workloads (RLock has higher overhead than Lock).
• Forgetting to RUnlock (causes deadlock).
• Copying a mutex after first use (both Mutex and RWMutex are not safe to copy).
• Using RWMutex when all operations are writes (just use Mutex).
• Not using defer for unlocking (can lead to deadlocks on panics).