func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 启动前加 1
        go worker(i, &wg)
    }
    wg.Wait() // 等待所有任务结束
}

type SafeCounter struct {
    mu    sync.RWMutex
    stats map[string]int
}

func (c *SafeCounter) Read(key string) int {
    c.mu.RLock()         // 读锁，多个 Goroutine 可同时进入
    defer c.mu.RUnlock()
    return c.stats[key]
}

func (c *SafeCounter) Write(key string, val int) {
    c.mu.Lock()          // 写锁，排他
    defer c.mu.Unlock()
    c.stats[key] = val
}

var (
    once     sync.Once
    instance *Database
)

func GetDB() *Database {
    once.Do(func() {
        instance = &Database{Conn: "Initialized"}
        fmt.Println("DB Instance Created")
    })
    return instance
}

func condExample() {
    l := sync.NewCond(&sync.Mutex{})
    ready := false

    go func() {
        time.Sleep(time.Second)
        l.L.Lock()
        ready = true
        l.L.Unlock()
        l.Broadcast() // 唤醒所有等待者
    }()

    l.L.Lock()
    for !ready { // 必须在 for 循环中检查，防止虚假唤醒
        l.Wait()
    }
    fmt.Println("Ready now!")
    l.L.Unlock()
}

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func log(data string) {
    b := bufPool.Get().(*bytes.Buffer)
    b.Reset()
    b.WriteString(data)
    // 使用完毕后放回
    bufPool.Put(b)
}

func SafeGo(f func()) {
    go func() {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
            }
        }()
        f()
    }()
}

for i := 0; i < 5; i++ {
    go func(id int) { 
        fmt.Println(id) // id 是局部副本
    }(i)
}

for i := 0; i < 5; i++ {
    i := i // 在循环体内重新赋值，为每轮迭代创建独立副本
    go func() {
        fmt.Println(i) // 这里的 i 指向当前迭代的副本地址
    }()
}