Golanggoroutine与Timer结合实现定时任务

time

time.Timer

time.Ticker

time.After

time.After

go func() {
    fmt.Println("开始等待5秒...")
    <-time.After(5 * time.Second)
    fmt.Println("5秒后执行了一次任务。")
}()
// 为了让主程序不立即退出，通常需要一个等待机制，比如time.Sleep或一个select{}
// time.Sleep(6 * time.Second)

time.After

time.NewTimer

*time.Timer

timer := time.NewTimer(10 * time.Second)
go func() {
    fmt.Println("NewTimer开始等待10秒...")
    <-timer.C // 等待计时器触发
    fmt.Println("10秒后执行了一次任务，通过NewTimer。")
}()
// 假设我们可以在某个点取消它，比如在5秒后
// time.Sleep(5 * time.Second)
// if timer.Stop() { // 尝试停止计时器
//     fmt.Println("Timer被提前停止了。")
// } else {
//     // 如果Stop返回false，说明计时器已经触发或正在触发
//     // 此时需要从通道中读取一次，以清空通道，避免后续的读取阻塞
//     select {
//     case <-timer.C:
//     default:
//     }
//     fmt.Println("Timer已触发，无法停止。")
// }
// time.Sleep(6 * time.Second) // 确保有足够时间观察结果

time.NewTicker

Stop()

ticker := time.NewTicker(2 * time.Second)
stopSignal := make(chan struct{}) // 用于优雅停止任务

go func() {
    defer ticker.Stop() // 确保Ticker在goroutine退出时停止
    fmt.Println("Ticker开始每2秒执行任务...")
    for {
        select {
        case t := <-ticker.C:
            fmt.Printf("每2秒执行一次任务，当前时间: %s\n", t.Format("15:04:05"))
            // 模拟一个可能耗时的任务，但通常不应该在这里阻塞太久
            // time.Sleep(500 * time.Millisecond)
        case <-stopSignal:
            fmt.Println("收到停止信号，Ticker任务即将退出。")
            return // 退出goroutine
        }
    }
}()

// 主协程中，等待一段时间后发送停止信号
// time.Sleep(10 * time.Second)
// close(stopSignal) // 发送停止信号
// fmt.Println("主程序已发送停止信号给Ticker任务。")
// time.Sleep(1 * time.Second) // 给goroutine一点时间处理退出

time.Timer

time.Ticker

time.Sleep

time.Timer

time.NewTimer

Stop()

Reset()

time.Ticker

Ticker

Stop()

time.NewTimer

Reset

Ticker

time.NewTicker

Ticker

done

stop

close(stopChan)

select

time.Ticker

ticker.Stop()

// 示例：优雅停止周期性任务
func StartPeriodicTask(interval time.Duration, stopChan <-chan struct{}) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop() // 确保Ticker在函数退出时停止

    fmt.Printf("周期性任务启动，间隔 %v\n", interval)
    for {
        select {
        case <-ticker.C:
            fmt.Println("执行周期性任务...")
            // 实际任务逻辑
        case <-stopChan:
            fmt.Println("收到停止信号，任务即将退出。")
            return // 退出goroutine
        }
    }
}

// 调用示例
/*
func main() {
    stop := make(chan struct{})
    go StartPeriodicTask(1 * time.Second, stop)

    time.Sleep(5 * time.Second) // 运行一段时间
    close(stop)                 // 发送停止信号
    fmt.Println("主程序已发送停止信号。")
    time.Sleep(50 * time.Millisecond) // 给goroutine一点时间处理退出
    fmt.Println("主程序退出。")
}
*/

time.Timer

timer.Stop()

Stop()

false

timer.C

select

// 示例：优雅停止一次性任务的等待
func StartOneOffTask(delay time.Duration, stopChan <-chan struct{}) {
    timer := time.NewTimer(delay)
    defer func() {
        // 确保timer被停止或其通道被清空
        if !timer.Stop() {
            select {
            case <-timer.C: // 清空通道
            default:
            }
        }
    }()

    fmt.Printf("一次性任务启动，等待 %v\n", delay)
    select {
    case <-timer.C:
        fmt.Println("Timer触发了，执行一次性任务。")
    case <-stopChan: // 同样可以用stopChan来停止等待中的Timer
        fmt.Println("收到停止信号，一次性任务被外部停止，未触发。")
    }
}

// 调用示例
/*
func main() {
    stop := make(chan struct{})
    go StartOneOffTask(5 * time.Second, stop)

    time.Sleep(2 * time.Second) // 在Timer触发前发送停止信号
    close(stop)
    fmt.Println("主程序已发送停止信号给一次性任务。")
    time.Sleep(1 * time.Second) // 给goroutine一点时间处理退出
    fmt.Println("主程序退出。")
}
*/

defer ticker.Stop()

stop

timer.Stop()

ticker.C

timer.C

select

// 错误示范（可能阻塞定时器goroutine）
/*
case <-ticker.C:
    // 这里执行一个需要10秒的任务，如果ticker是每1秒触发，就会