Go语言并发定时任务之从Sleep到Context的8种写法全解析

func UseTimeSleep() {
    for i := 1; i <= 10; i++ {
        // 暂停当前goroutine的执行1秒钟
        // time.Second是预定义的Duration常量，等于1,000,000,000纳秒
        time.Sleep(time.Second)

        // 打印当前数字
        fmt.Println(i)
    }
}

func UseTimeAfter() {
    for i := 1; i <= 10; i++ {
        // time.After返回一个单向接收通道(<-chan Time)
        // 该通道会在指定时间后发送一个时间值
        timerChannel := time.After(time.Second)

        // <-操作符会阻塞，直到通道发送值
        <-timerChannel

        fmt.Println(i)
    }
}

func UseTimeTicker() {
    // 创建Ticker对象，每1秒向C通道发送当前时间
    ticker := time.NewTicker(time.Second)

    // defer确保函数退出时停止Ticker，释放资源
    defer ticker.Stop()

    for i := 1; i <= 10; i++ {
        // 从Ticker的C通道读取值（阻塞直到时间到）
        <-ticker.C

        fmt.Println(i)
    }
}

func UseChannel() {
    // 创建无缓冲通道，发送和接收会同步阻塞
    ch := make(chan int)

    for i := 1; i <= 10; i++ {
        // 启动goroutine（轻量级线程）
        go func(num int) {
            // 每个goroutine等待不同时间
            time.Sleep(time.Second * time.Duration(num))

            // 向通道发送数字
            ch <- num
        }(i) // 注意：必须传入i的副本，避免闭包捕获问题
    }

    for i := 1; i <= 10; i++ {
        // 从通道接收值（阻塞直到有数据）
        value := <-ch
        fmt.Println(value)
    }
}

func UseGoroutine() {
    // 创建WaitGroup用于等待所有goroutine完成
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        // 增加等待计数
        wg.Add(1)

        go func(num int) {
            // 函数退出时减少计数
            defer wg.Done()

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

    // 阻塞直到所有goroutine完成
    wg.Wait()
}

func UseSingleGoroutine() {
    var wg sync.WaitGroup

    // 只需等待1个goroutine
    wg.Add(1)

    // 启动工作goroutine
    go func() {
        // 确保结束时通知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监控多个通道操作
        select {
        // 当ticker.C有值时执行
        case <-ticker.C:
            fmt.Println(i)
        }
    }
}

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

func UseContextWithTicker() {
    // 创建可取消的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: // 定时触发
            fmt.Println(i)
            i++
            if i > 10 {
                return // 自然结束
            }

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

// 带超时的context
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 在数据库查询中使用
err := db.QueryContext(ctx, "SELECT...")

package main

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

// 所有实现函数（前面已详细解释）

func main() {
    fmt.Println("=== 基础: time.Sleep ===")
    UseTimeSleep()

    fmt.Println("\n=== 基础: time.After ===")
    UseTimeAfter()

    fmt.Println("\n=== 基础: time.Ticker ===")
    UseTimeTicker()

    fmt.Println("\n=== 误区: Channel并发 ===")
    UseChannel()

    fmt.Println("\n=== 误区: WaitGroup并发 ===")
    UseGoroutine()

    fmt.Println("\n=== 正确: 单goroutine+WaitGroup ===")
    UseSingleGoroutine()

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

    fmt.Println("\n=== 生产推荐: context+Ticker ===")
    UseContextWithTicker()

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

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