Read–Write Lock Pattern #

// ANTI-PATTERN: plain Mutex for all operations — readers block each other
type SlowCache struct {
	mu   sync.Mutex // ✗ exclusive for all operations
	data map[string]string
}

func (c *SlowCache) Get(key string) (string, bool) {
	c.mu.Lock()         // ✗ even reads must queue exclusively
	defer c.mu.Unlock()
	val, ok := c.data[key]
	return val, ok
}

func (c *SlowCache) Set(key, value string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.data[key] = value
}

// CORRECT: RWMutex — many readers may enter simultaneously
type FastCache struct {
	mu   sync.RWMutex // ✓ distinguishes read and write
	data map[string]string
}

func (c *FastCache) Get(key string) (string, bool) {
	c.mu.RLock()         // ✓ many goroutines can RLock simultaneously
	defer c.mu.RUnlock()
	val, ok := c.data[key]
	return val, ok
}

func (c *FastCache) Set(key, value string) {
	c.mu.Lock()         // ✓ writes stay exclusive
	defer c.mu.Unlock()
	c.data[key] = value
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// Cache is a thread-safe in-memory key-value store
type Cache struct {
	mu      sync.RWMutex
	data    map[string]cacheEntry
}

type cacheEntry struct {
	value     string
	expiresAt time.Time
}

func NewCache() *Cache {
	return &Cache{
		data: make(map[string]cacheEntry),
	}
}

// Get reads a value from the cache — RLock lets many goroutines read in parallel
func (c *Cache) Get(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()

	entry, ok := c.data[key]
	if !ok {
		return "", false
	}

	// Check whether the entry has expired
	if time.Now().After(entry.expiresAt) {
		return "", false // entry expired, but do not delete here (needs a write lock)
	}

	return entry.value, true
}

// Set writes a value to the cache — an exclusive Lock is required
func (c *Cache) Set(key, value string, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()

	c.data[key] = cacheEntry{
		value:     value,
		expiresAt: time.Now().Add(ttl),
	}
}

// Delete removes an entry from the cache — an exclusive Lock is required
func (c *Cache) Delete(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	delete(c.data, key)
}

// Evict removes all expired entries
// This is a heavier write operation — an exclusive Lock is required
func (c *Cache) Evict() int {
	c.mu.Lock()
	defer c.mu.Unlock()

	now := time.Now()
	count := 0
	for key, entry := range c.data {
		if now.After(entry.expiresAt) {
			delete(c.data, key)
			count++
		}
	}
	return count
}

// Size returns the number of entries — RLock is enough because it only reads
func (c *Cache) Size() int {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return len(c.data)
}

func main() {
	cache := NewCache()

	// Write some values
	cache.Set("user:1", `{"name":"Alice"}`, 5*time.Minute)
	cache.Set("user:2", `{"name":"Bob"}`, 5*time.Minute)
	cache.Set("config:timeout", "30s", 1*time.Hour)

	// Simulate many concurrent readers
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			if val, ok := cache.Get("user:1"); ok {
				fmt.Printf("[Reader %d] user:1 = %s\n", id, val)
			}
		}(i)
	}

	wg.Wait()
	fmt.Printf("Cache size: %d\n", cache.Size())
}

package main

import (
	"fmt"
	"sync"
)

type Config struct {
	mu     sync.RWMutex
	values map[string]interface{}
}

func NewConfig(initial map[string]interface{}) *Config {
	c := &Config{
		values: make(map[string]interface{}),
	}
	for k, v := range initial {
		c.values[k] = v
	}
	return c
}

// Get reads a single configuration value
func (c *Config) Get(key string) (interface{}, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val, ok := c.values[key]
	return val, ok
}

// GetString is a helper for string values
func (c *Config) GetString(key, defaultVal string) string {
	c.mu.RLock()
	defer c.mu.RUnlock()
	if val, ok := c.values[key]; ok {
		if s, ok := val.(string); ok {
			return s
		}
	}
	return defaultVal
}

// GetInt is a helper for integer values
func (c *Config) GetInt(key string, defaultVal int) int {
	c.mu.RLock()
	defer c.mu.RUnlock()
	if val, ok := c.values[key]; ok {
		if i, ok := val.(int); ok {
			return i
		}
	}
	return defaultVal
}

// Reload replaces the entire configuration at once — an exclusive write operation
// Replacing the whole map at once (atomic swap) is safer than per-key updates
func (c *Config) Reload(newValues map[string]interface{}) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.values = newValues // ✓ replace the whole map at once
}

// Update changes a single value
func (c *Config) Update(key string, value interface{}) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.values[key] = value
}

func main() {
	cfg := NewConfig(map[string]interface{}{
		"max_connections": 100,
		"timeout_seconds": 30,
		"environment":     "production",
	})

	// Many goroutines read the config simultaneously
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			env := cfg.GetString("environment", "development")
			maxConn := cfg.GetInt("max_connections", 10)
			fmt.Printf("[Worker %d] env=%s, max_conn=%d\n", id, env, maxConn)
		}(i)
	}

	// Simulate a dynamic config reload in a separate goroutine
	wg.Add(1)
	go func() {
		defer wg.Done()
		cfg.Reload(map[string]interface{}{
			"max_connections": 200,
			"timeout_seconds": 60,
			"environment":     "production",
		})
		fmt.Println("[Config] Reloaded")
	}()

	wg.Wait()
}

// ANTI-PATTERN: lock upgrade — causes a deadlock
func (c *Cache) GetOrSet(key, value string) string {
	c.mu.RLock()
	if val, ok := c.data[key]; ok {
		c.mu.RUnlock()
		return val
	}
	// ✗ DON'T: still holding RLock, trying to Lock
	c.mu.Lock()         // DEADLOCK — Lock waits for all RLocks to finish,
	                    // including the RLock held by this goroutine itself
	defer c.mu.Unlock()
	c.data[key] = value
	return value
}

// CORRECT: release the RLock before taking the Lock
func (c *Cache) GetOrSet(key, value string) string {
	// Try reading first with RLock
	c.mu.RLock()
	if val, ok := c.data[key]; ok {
		c.mu.RUnlock() // ✓ release RLock before returning
		return val
	}
	c.mu.RUnlock() // ✓ release RLock before taking the Lock

	// Take the write lock to write
	c.mu.Lock()
	defer c.mu.Unlock()

	// Double-check after getting the write lock
	// (another goroutine may have written while we waited for the Lock)
	if val, ok := c.data[key]; ok {
		return val // ✓ another goroutine already filled it, use its value
	}

	c.data[key] = value
	return value
}

// ✗ Using RLock for a write operation — data race
func (c *Cache) BuggySet(key, value string) {
	c.mu.RLock()        // ✗ this is a read lock, not a write lock
	defer c.mu.RUnlock()
	c.data[key] = value // ✗ writing with a read lock = data race
}

// ✓ Always use Lock() for write operations
func (c *Cache) SafeSet(key, value string) {
	c.mu.Lock()         // ✓ write lock
	defer c.mu.Unlock()
	c.data[key] = value
}

// ✗ Operations outside the lock — data not protected
func (c *Cache) BuggyGet(key string) string {
	c.mu.RLock()
	val := c.data[key]
	c.mu.RUnlock()
	return val + "-suffix" // ✓ this is safe — transformation after unlock is fine
	// ✗ what is unsafe is ACCESSING c.data after RUnlock
}

// ✗ Storing a reference to protected data outside the lock
func (c *Cache) BuggyRef(key string) *string {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val := c.data[key]
	return &val // ✗ if val is a pointer to internal data, it can be raced after unlock
}

// ✓ Return a copy of the value, not a reference to internal data
func (c *Cache) SafeGet(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val, ok := c.data[key]
	return val, ok // ✓ a string is a value type — this is a safe copy
}

// ✗ Forgetting to unlock on all paths — other goroutines will deadlock
func (c *Cache) ForgetfulGet(key string) string {
	c.mu.RLock()
	val, ok := c.data[key]
	if !ok {
		return "" // ✗ forgot c.mu.RUnlock() before returning
	}
	c.mu.RUnlock()
	return val
}

// ✓ Always use defer to ensure the unlock happens
func (c *Cache) DeferredGet(key string) string {
	c.mu.RLock()
	defer c.mu.RUnlock() // ✓ defer ensures unlock on all return paths
	val := c.data[key]
	return val
}

// ✗ Heavy operations inside the critical section — blocks all readers/writers
func (c *Cache) HeavyCompute(key string) string {
	c.mu.Lock()
	defer c.mu.Unlock()
	val := c.data[key]
	result := expensiveTransformation(val) // ✗ heavy computation inside the lock
	c.data[key] = result
	return result
}

// ✓ Take the data, compute outside the lock, then store the result
func (c *Cache) LightLock(key string) string {
	c.mu.RLock()
	val := c.data[key]
	c.mu.RUnlock() // ✓ release the lock before heavy computation

	result := expensiveTransformation(val) // computation outside the lock

	c.mu.Lock()
	c.data[key] = result // ✓ lock only for the fast write operation
	c.mu.Unlock()
	return result
}