package main

import (
    "fmt"
    "sync"
)

type SafeCounter struct {
    mu    sync.Mutex
    count int
}

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

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

func main() {
    counter := &SafeCounter{}
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }

    wg.Wait()
    fmt.Println("计数:", counter.Value()) // 1000
}

package main

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

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

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

func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()         // 读锁
    defer c.mu.RUnlock()
    val, ok := c.data[key]
    return val, ok
}

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

func (c *Cache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.data, key)
}

func (c *Cache) Len() int {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return len(c.data)
}

func main() {
    cache := NewCache()
    var wg sync.WaitGroup

    // 并发写入
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            cache.Set(fmt.Sprintf("key-%d", i), fmt.Sprintf("value-%d", i))
        }(i)
    }

    // 并发读取
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            if val, ok := cache.Get(fmt.Sprintf("key-%d", i)); ok {
                _ = val
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("缓存大小:", cache.Len())
}

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

func processTask(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("任务 %d 开始\n", id)
    time.Sleep(time.Duration(id*100) * time.Millisecond)
    fmt.Printf("任务 %d 完成\n", id)
}

func main() {
    var wg sync.WaitGroup

    tasks := 5
    wg.Add(tasks) // 一次添加多个

    for i := 1; i <= tasks; i++ {
        go processTask(i, &wg)
    }

    wg.Wait()
    fmt.Println("所有任务完成")
}

package main

import (
    "fmt"
    "sync"
)

type Database struct {
    Host string
    Port int
}

var (
    dbInstance *Database
    dbOnce     sync.Once
)

func GetDatabase() *Database {
    dbOnce.Do(func() {
        fmt.Println("初始化数据库连接（只执行一次）")
        dbInstance = &Database{
            Host: "localhost",
            Port: 5432,
        }
    })
    return dbInstance
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            db := GetDatabase()
            _ = db
        }()
    }
    wg.Wait()
    // 输出: "初始化数据库连接（只执行一次）" 只出现一次
}

package main

import (
    "bytes"
    "fmt"
    "sync"
)

// 创建 buffer 池
var bufferPool = sync.Pool{
    New: func() any {
        return new(bytes.Buffer)
    },
}

func processRequest(data string) string {
    // 从池中获取
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()           // 清空
        bufferPool.Put(buf)   // 归还
    }()

    buf.WriteString("处理: ")
    buf.WriteString(data)
    return buf.String()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            result := processRequest(fmt.Sprintf("请求-%d", i))
            _ = result
        }(i)
    }
    wg.Wait()
    fmt.Println("完成")
}

// 第九章已详细介绍，此处简要对比
var m sync.Map

// 存储
m.Store("key", "value")

// 读取
v, ok := m.Load("key")

// 原子操作
v, loaded := m.LoadOrStore("key", "default")

package main

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

type Queue struct {
    items []int
    mu    sync.Mutex
    cond  *sync.Cond
}

func NewQueue() *Queue {
    q := &Queue{}
    q.cond = sync.NewCond(&q.mu)
    return q
}

func (q *Queue) Put(item int) {
    q.mu.Lock()
    defer q.mu.Unlock()
    q.items = append(q.items, item)
    q.cond.Signal() // 通知一个等待者
}

func (q *Queue) Get() int {
    q.mu.Lock()
    defer q.mu.Unlock()
    for len(q.items) == 0 {
        q.cond.Wait() // 等待通知
    }
    item := q.items[0]
    q.items = q.items[1:]
    return item
}

func main() {
    q := NewQueue()

    // 消费者
    go func() {
        for i := 0; i < 5; i++ {
            item := q.Get()
            fmt.Printf("消费: %d\n", item)
        }
    }()

    // 生产者
    for i := 1; i <= 5; i++ {
        time.Sleep(200 * time.Millisecond)
        fmt.Printf("生产: %d\n", i)
        q.Put(i)
    }

    time.Sleep(time.Second)
}

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    // 原子计数器
    var counter int64
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            atomic.AddInt64(&counter, 1)
        }()
    }
    wg.Wait()
    fmt.Println("计数:", atomic.LoadInt64(&counter)) // 1000

    // 原子比较并交换（CAS）
    var value int64 = 100
    swapped := atomic.CompareAndSwapInt64(&value, 100, 200)
    fmt.Println(swapped, value) // true, 200

    // 原子值
    var config atomic.Value
    config.Store(map[string]string{"env": "dev"})
    
    go func() {
        time.Sleep(time.Second)
        config.Store(map[string]string{"env": "prod"})
    }()

    v := config.Load().(map[string]string)
    fmt.Println(v["env"])
}