What is sync.Mutex and when do you use sync.RWMutex instead?

// sync.Mutex — protect any shared mutable state
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Add(n int) {
    c.mu.Lock()
    defer c.mu.Unlock()  // always use defer — runs even on panic
    c.count += n
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

// sync.RWMutex — read-heavy workloads (e.g. config, caches)
type SafeConfig struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *SafeConfig) Get(key string) string {
    c.mu.RLock()           // multiple goroutines can hold RLock at once
    defer c.mu.RUnlock()
    return c.data[key]
}

func (c *SafeConfig) Set(key, val string) {
    c.mu.Lock()            // exclusive — no readers OR writers allowed
    defer c.mu.Unlock()
    c.data[key] = val
}

// RULES:
// 1. Never copy a Mutex after first use (lock state would be duplicated)
// 2. Always pass struct containing Mutex as a pointer (*SafeCounter)
// 3. Mutex is NOT reentrant — a goroutine holding Lock() will deadlock
//    if it calls Lock() again on the same mutex