sync 包（WaitGroup / Mutex / Once）

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 结束前把计数器减 1（defer 保证即使中途 panic 也会减，避免死锁）
    fmt.Printf("worker %d 开始\n", id)
    time.Sleep(100 * time.Millisecond) // 模拟干活
    fmt.Printf("worker %d 结束\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1) // ⚠️ Add 必须在 go 之前！计数器先 +1
        go worker(i, &wg) // 注意传指针：WaitGroup 内部要改计数
    }

    wg.Wait() // 阻塞直到所有 Done，相当于「等这一批全部 join」
    fmt.Println("所有 worker 都结束了")
}

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mu      sync.Mutex // 保护 counter
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()          // 上锁
            counter++          // 临界区：同时只有一个 goroutine
            mu.Unlock()        // 解锁（或用 defer 更安全）
        }()
    }
    wg.Wait()
    fmt.Println("counter =", counter) // 1000，无丢失
}

func incrementSafe() {
    mu.Lock()
    defer mu.Unlock() // 无论发生什么都会解锁
    counter++
}

// ❌ 把 Mutex 放进结构体后把这个结构体值复制/传递，等于复制一份锁状态（可能已锁）
// type Counter struct { mu sync.Mutex; n int }
// c2 := c1 // ❌ go vet 会警告：同步原语不该被拷贝

// ✅ 传指针对

package main

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

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

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

func (c *Cache) Get(key string) int {
    c.mu.RLock()         // 读锁：多个读者可同时进入
    defer c.mu.RUnlock()
    return c.store[key]
}

func (c *Cache) Set(key string, v int) {
    c.mu.Lock()          // 写锁：独占，等所有读者离开
    defer c.mu.Unlock()
    c.store[key] = v
}

func main() {
    cache := NewCache()
    cache.Set("a", 1)

    var wg sync.WaitGroup
    // 5 个并发读者
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                _ = cache.Get("a")
                time.Sleep(100 * time.Microsecond)
            }
        }()
    }
    // 1 个写者
    wg.Add(1)
    go func() {
        defer wg.Done()
        for j := 0; j < 10; j++ {
            cache.Set("a", j)
        }
    }()

    wg.Wait()
    fmt.Println("最终值:", cache.Get("a"))
}

package main

import (
    "fmt"
    "sync"
)

var (
    once sync.Once
    config map[string]string
)

func loadConfig() {
    fmt.Println("开始加载配置……（只应执行一次）")
    // 模拟读文件 / 网络
    config = map[string]string{"host": "localhost", "port": "8080"}
    fmt.Println("配置加载完成")
}

func GetConfig() map[string]string {
    once.Do(loadConfig) // 无论多少个 goroutine 调用，Do 只真正执行一次
    return config
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            _ = GetConfig() // 10 个 goroutine 并发调用，只有 1 次真的执行加载
        }()
    }
    wg.Wait()
    fmt.Println("配置:", GetConfig())
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    heavy := sync.OnceValue(func() string { // 返回值的 Once
        fmt.Println("只执行一次的昂贵计算")
        return "hello once"
    })

    for i := 0; i < 3; i++ {
        fmt.Println(heavy()) // 多次调用，内部计算只跑一次
    }
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map

    m.Store("a", 1)          // 写
    v, ok := m.Load("a")     // 读
    fmt.Println(v, ok)       // 1 true

    m.LoadOrStore("b", 2)    // 没有才存，返回现有值
    fmt.Println(m.Load("b")) // 2 true

    m.Range(func(k, v any) bool { // 遍历
        fmt.Printf("%v=%v\n", k, v)
        return true // 返回 false 可提前终止
    })
}

package main

import (
    "errors"
    "fmt"
    "time"

    "golang.org/x/sync/errgroup"
)

func main() {
    var g errgroup.Group

    // 三个并发任务，其中一个会失败
    for i := 1; i <= 3; i++ {
        i := i
        g.Go(func() error {
            time.Sleep(time.Duration(i) * 50 * time.Millisecond)
            if i == 2 {
                return errors.New("任务 2 失败了")
            }
            return nil
        })
    }

    err := g.Wait() // 等全部结束，返回第一个非 nil 错误（取消其他任务的语义需配合 context）
    fmt.Println("err =", err)
}