Sync Package: Mutex, RWMutex, Once, Cond, and Atomics

// Mutex: exclusive access
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// RWMutex: multiple readers OR one writer
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *Cache) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.data[key]
}

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

var (
    instance *Database
    once     sync.Once
)

func GetDB() *Database {
    once.Do(func() {
        instance = &Database{}
        instance.Connect()
    })
    return instance
}

// Q: What if once.Do(f) panics?
// A: It counts as "done" - won't retry!

var wg sync.WaitGroup

for i := 0; i < 10; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        process(i)
    }(i)
}

wg.Wait() // Blocks until all Done() called

// Broadcast to multiple waiting goroutines
type Barrier struct {
    cond  *sync.Cond
    ready bool
}

func NewBarrier() *Barrier {
    return &Barrier{
        cond: sync.NewCond(&sync.Mutex{}),
    }
}

func (b *Barrier) Wait() {
    b.cond.L.Lock()
    for !b.ready {
        b.cond.Wait() // Releases lock while waiting
    }
    b.cond.L.Unlock()
}

func (b *Barrier) Release() {
    b.cond.L.Lock()
    b.ready = true
    b.cond.Broadcast() // Wake all waiters
    b.cond.L.Unlock()
}

import "sync/atomic"

var counter int64

// Atomic increment (faster than mutex for simple ops)
atomic.AddInt64(&counter, 1)

// Load/Store
val := atomic.LoadInt64(&counter)
atomic.StoreInt64(&counter, 100)

// Compare and Swap
swapped := atomic.CompareAndSwapInt64(&counter, 100, 200)

// atomic.Value for complex types
var config atomic.Value
config.Store(Config{Debug: true})
cfg := config.Load().(Config)

// Use when: write-once read-many, or disjoint key sets
var m sync.Map

m.Store("key", "value")
val, ok := m.Load("key")
m.Delete("key")

m.Range(func(key, value interface{}) bool {
    fmt.Println(key, value)
    return true // continue iteration
})