func UseTimeSleep() {
    for i := 1; i <= 10; i++ {
        // 暫停當(dāng)前goroutine的執(zhí)行1秒鐘
        // time.Second是預(yù)定義的Duration常量，等于1,000,000,000納秒
        time.Sleep(time.Second)

        // 打印當(dāng)前數(shù)字
        fmt.Println(i)
    }
}

func UseTimeAfter() {
    for i := 1; i <= 10; i++ {
        // time.After返回一個(gè)單向接收通道(<-chan Time)
        // 該通道會(huì)在指定時(shí)間后發(fā)送一個(gè)時(shí)間值
        timerChannel := time.After(time.Second)

        // <-操作符會(huì)阻塞，直到通道發(fā)送值
        <-timerChannel

        fmt.Println(i)
    }
}

func UseTimeTicker() {
    // 創(chuàng)建Ticker對(duì)象，每1秒向C通道發(fā)送當(dāng)前時(shí)間
    ticker := time.NewTicker(time.Second)

    // defer確保函數(shù)退出時(shí)停止Ticker，釋放資源
    defer ticker.Stop()

    for i := 1; i <= 10; i++ {
        // 從Ticker的C通道讀取值（阻塞直到時(shí)間到）
        <-ticker.C

        fmt.Println(i)
    }
}

func UseChannel() {
    // 創(chuàng)建無(wú)緩沖通道，發(fā)送和接收會(huì)同步阻塞
    ch := make(chan int)

    for i := 1; i <= 10; i++ {
        // 啟動(dòng)goroutine（輕量級(jí)線(xiàn)程）
        go func(num int) {
            // 每個(gè)goroutine等待不同時(shí)間
            time.Sleep(time.Second * time.Duration(num))

            // 向通道發(fā)送數(shù)字
            ch <- num
        }(i) // 注意：必須傳入i的副本，避免閉包捕獲問(wèn)題
    }

    for i := 1; i <= 10; i++ {
        // 從通道接收值（阻塞直到有數(shù)據(jù)）
        value := <-ch
        fmt.Println(value)
    }
}

func UseGoroutine() {
    // 創(chuàng)建WaitGroup用于等待所有g(shù)oroutine完成
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        // 增加等待計(jì)數(shù)
        wg.Add(1)

        go func(num int) {
            // 函數(shù)退出時(shí)減少計(jì)數(shù)
            defer wg.Done()

            time.Sleep(time.Second * time.Duration(num))
            fmt.Println(num)
        }(i)
    }

    // 阻塞直到所有g(shù)oroutine完成
    wg.Wait()
}

func UseSingleGoroutine() {
    var wg sync.WaitGroup

    // 只需等待1個(gè)goroutine
    wg.Add(1)

    // 啟動(dòng)工作goroutine
    go func() {
        // 確保結(jié)束時(shí)通知WaitGroup
        defer wg.Done()

        for i := 1; i <= 10; i++ {
            fmt.Println(i)
            time.Sleep(time.Second)
        }
    }()

    // 主goroutine等待工作完成
    wg.Wait()
}

func UseSelectAndTicker() {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()

    for i := 1; i <= 10; i++ {
        // select監(jiān)控多個(gè)通道操作
        select {
        // 當(dāng)ticker.C有值時(shí)執(zhí)行
        case <-ticker.C:
            fmt.Println(i)
        }
    }
}

quit := make(chan struct{})
// ...
select {
case <-ticker.C:
    fmt.Println(i)
case <-quit:
    fmt.Println("提前退出")
    return
}

func UseContextWithTicker() {
    // 創(chuàng)建可取消的context
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 確保資源釋放

    ticker := time.NewTicker(time.Second)
    defer ticker.Stop() // 確保停止ticker

    i := 1
    for {
        select {
        case <-ticker.C: // 定時(shí)觸發(fā)
            fmt.Println(i)
            i++
            if i > 10 {
                return // 自然結(jié)束
            }

        case <-ctx.Done(): // 上下文取消
            fmt.Println("任務(wù)取消:", ctx.Err())
            return
        }
    }
}

// 帶超時(shí)的context
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 在數(shù)據(jù)庫(kù)查詢(xún)中使用
err := db.QueryContext(ctx, "SELECT...")

package main

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

// 所有實(shí)現(xiàn)函數(shù)（前面已詳細(xì)解釋?zhuān)?

func main() {
    fmt.Println("=== 基礎(chǔ): time.Sleep ===")
    UseTimeSleep()

    fmt.Println("\n=== 基礎(chǔ): time.After ===")
    UseTimeAfter()

    fmt.Println("\n=== 基礎(chǔ): time.Ticker ===")
    UseTimeTicker()

    fmt.Println("\n=== 誤區(qū): Channel并發(fā) ===")
    UseChannel()

    fmt.Println("\n=== 誤區(qū): WaitGroup并發(fā) ===")
    UseGoroutine()

    fmt.Println("\n=== 正確: 單goroutine+WaitGroup ===")
    UseSingleGoroutine()

    fmt.Println("\n=== 正確: select+Ticker ===")
    UseSelectAndTicker()

    fmt.Println("\n=== 生產(chǎn)推薦: context+Ticker ===")
    UseContextWithTicker()

    fmt.Println("\n=== 所有示例執(zhí)行完成 ===")
}

select {
case <-ctx.Done():
    return ctx.Err()
case err := <-errCh:
    return err
}