Read–Write Lock Pattern #

// ANTI-PATTERN: Mutex biasa untuk semua operasi — reader saling menghalangi
type SlowCache struct {
	mu   sync.Mutex // ✗ eksklusif untuk semua operasi
	data map[string]string
}

func (c *SlowCache) Get(key string) (string, bool) {
	c.mu.Lock()         // ✗ bahkan read pun harus antre eksklusif
	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
}

// BENAR: RWMutex — banyak reader boleh masuk bersamaan
type FastCache struct {
	mu   sync.RWMutex // ✓ membedakan read dan write
	data map[string]string
}

func (c *FastCache) Get(key string) (string, bool) {
	c.mu.RLock()         // ✓ banyak goroutine bisa RLock bersamaan
	defer c.mu.RUnlock()
	val, ok := c.data[key]
	return val, ok
}

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

package main

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

// Cache adalah 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 membaca nilai dari cache — RLock memungkinkan banyak goroutine membaca paralel
func (c *Cache) Get(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()

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

	// Cek apakah entry sudah kedaluwarsa
	if time.Now().After(entry.expiresAt) {
		return "", false // entry expired, tapi jangan hapus di sini (butuh write lock)
	}

	return entry.value, true
}

// Set menulis nilai ke cache — Lock eksklusif diperlukan
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 menghapus entry dari cache — Lock eksklusif diperlukan
func (c *Cache) Delete(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	delete(c.data, key)
}

// Evict menghapus semua entry yang sudah kedaluwarsa
// Ini adalah operasi write yang lebih berat — Lock eksklusif diperlukan
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 mengembalikan jumlah entry — RLock cukup karena hanya membaca
func (c *Cache) Size() int {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return len(c.data)
}

func main() {
	cache := NewCache()

	// Tulis beberapa nilai
	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)

	// Simulasi banyak reader concurrent
	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 membaca satu nilai konfigurasi
func (c *Config) Get(key string) (interface{}, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val, ok := c.values[key]
	return val, ok
}

// GetString adalah helper untuk nilai string
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 adalah helper untuk nilai integer
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 mengganti seluruh konfigurasi sekaligus — operasi write eksklusif
// Mengganti seluruh map sekaligus (atomic swap) lebih aman daripada update per-key
func (c *Config) Reload(newValues map[string]interface{}) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.values = newValues // ✓ replace seluruh map sekaligus
}

// Update mengubah satu nilai saja
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",
	})

	// Banyak goroutine membaca config secara bersamaan
	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)
	}

	// Simulasi dynamic config reload di goroutine terpisah
	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 — menyebabkan deadlock
func (c *Cache) GetOrSet(key, value string) string {
	c.mu.RLock()
	if val, ok := c.data[key]; ok {
		c.mu.RUnlock()
		return val
	}
	// ✗ JANGAN: masih memegang RLock, mencoba Lock
	c.mu.Lock()         // DEADLOCK — Lock menunggu semua RLock selesai,
	                    // termasuk RLock yang dipegang goroutine ini sendiri
	defer c.mu.Unlock()
	c.data[key] = value
	return value
}

// BENAR: lepas RLock sebelum mengambil Lock
func (c *Cache) GetOrSet(key, value string) string {
	// Coba baca dulu dengan RLock
	c.mu.RLock()
	if val, ok := c.data[key]; ok {
		c.mu.RUnlock() // ✓ lepas RLock sebelum return
		return val
	}
	c.mu.RUnlock() // ✓ lepas RLock sebelum mengambil Lock

	// Ambil write lock untuk menulis
	c.mu.Lock()
	defer c.mu.Unlock()

	// Double-check setelah mendapat write lock
	// (goroutine lain mungkin sudah menulis saat kita menunggu Lock)
	if val, ok := c.data[key]; ok {
		return val // ✓ goroutine lain sudah mengisi, gunakan nilainya
	}

	c.data[key] = value
	return value
}

// ✗ Menggunakan RLock untuk operasi write — data race
func (c *Cache) BuggySet(key, value string) {
	c.mu.RLock()        // ✗ ini adalah read lock, bukan write lock
	defer c.mu.RUnlock()
	c.data[key] = value // ✗ write dengan read lock = data race
}

// ✓ Selalu gunakan Lock() untuk operasi write
func (c *Cache) SafeSet(key, value string) {
	c.mu.Lock()         // ✓ write lock
	defer c.mu.Unlock()
	c.data[key] = value
}

// ✗ Operasi di luar lock — data tidak terlindungi
func (c *Cache) BuggyGet(key string) string {
	c.mu.RLock()
	val := c.data[key]
	c.mu.RUnlock()
	return val + "-suffix" // ✓ ini aman — transformasi setelah unlock tidak masalah
	// ✗ yang tidak aman adalah MENGAKSES c.data setelah RUnlock
}

// ✗ Menyimpan referensi ke data yang dilindungi di luar lock
func (c *Cache) BuggyRef(key string) *string {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val := c.data[key]
	return &val // ✗ jika val adalah pointer ke data internal, bisa di-race setelah unlock
}

// ✓ Kembalikan salinan nilai, bukan referensi ke data internal
func (c *Cache) SafeGet(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	val, ok := c.data[key]
	return val, ok // ✓ string adalah value type — ini adalah salinan yang aman
}

// ✗ Lupa unlock dalam semua path — goroutine lain akan deadlock
func (c *Cache) ForgetfulGet(key string) string {
	c.mu.RLock()
	val, ok := c.data[key]
	if !ok {
		return "" // ✗ lupa c.mu.RUnlock() sebelum return
	}
	c.mu.RUnlock()
	return val
}

// ✓ Selalu gunakan defer untuk memastikan unlock terjadi
func (c *Cache) DeferredGet(key string) string {
	c.mu.RLock()
	defer c.mu.RUnlock() // ✓ defer memastikan unlock di semua path return
	val := c.data[key]
	return val
}

// ✗ Operasi berat di dalam critical section — memblokir semua reader/writer
func (c *Cache) HeavyCompute(key string) string {
	c.mu.Lock()
	defer c.mu.Unlock()
	val := c.data[key]
	result := expensiveTransformation(val) // ✗ komputasi berat di dalam lock
	c.data[key] = result
	return result
}

// ✓ Ambil data, lakukan komputasi di luar lock, lalu simpan hasilnya
func (c *Cache) LightLock(key string) string {
	c.mu.RLock()
	val := c.data[key]
	c.mu.RUnlock() // ✓ lepas lock sebelum komputasi berat

	result := expensiveTransformation(val) // komputasi di luar lock

	c.mu.Lock()
	c.data[key] = result // ✓ lock hanya untuk operasi write yang cepat
	c.mu.Unlock()
	return result
}