Golang中如何实现周期性任务调度

在Go语言中，虽然没有完全等同于Java ScheduledExecutorService的原生库，但可以通过标准库的time包和第三方库来实现生产环境可用的周期性任务调度。

使用标准库 time.Ticker

这是最符合Go语言习惯的解决方案：

package main

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

func scheduleTask(ctx context.Context, interval time.Duration, task func()) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    
    for {
        select {
        case <-ticker.C:
            task()
        case <-ctx.Done():
            return
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    
    task := func() {
        fmt.Println("Hello !!", time.Now().Format("15:04:05"))
    }
    
    // 启动周期性任务，每秒执行一次
    go scheduleTask(ctx, 1*time.Second, task)
    
    // 运行10秒后停止
    time.Sleep(10 * time.Second)
    cancel()
    fmt.Println("任务调度已停止")
}

使用第三方库 cron

对于更复杂的调度需求，推荐使用robfig/cron库：

package main

import (
    "fmt"
    "log"
    "time"
    
    "github.com/robfig/cron/v3"
)

func main() {
    c := cron.New()
    
    // 每秒执行一次
    _, err := c.AddFunc("@every 1s", func() {
        fmt.Println("Hello !!", time.Now().Format("15:04:05"))
    })
    
    if err != nil {
        log.Fatal(err)
    }
    
    // 启动调度器
    c.Start()
    
    // 运行10秒
    time.Sleep(10 * time.Second)
    
    // 优雅停止
    ctx := c.Stop()
    <-ctx.Done()
    fmt.Println("cron调度器已停止")
}

带错误处理的增强版本

package main

import (
    "fmt"
    "log"
    "time"
    "context"
)

type ScheduledTask struct {
    interval time.Duration
    task     func() error
}

func NewScheduledTask(interval time.Duration, task func() error) *ScheduledTask {
    return &ScheduledTask{
        interval: interval,
        task:     task,
    }
}

func (st *ScheduledTask) Run(ctx context.Context) {
    ticker := time.NewTicker(st.interval)
    defer ticker.Stop()
    
    for {
        select {
        case <-ticker.C:
            if err := st.task(); err != nil {
                log.Printf("任务执行失败: %v", err)
            }
        case <-ctx.Done():
            log.Println("任务调度已取消")
            return
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    
    task := func() error {
        fmt.Println("Hello !!", time.Now().Format("15:04:05"))
        return nil
    }
    
    scheduledTask := NewScheduledTask(1*time.Second, task)
    go scheduledTask.Run(ctx)
    
    // 运行一段时间后停止
    time.Sleep(10 * time.Second)
    cancel()
    time.Sleep(1 * time.Second) // 等待清理完成
}

多个任务调度管理器

package main

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

type TaskScheduler struct {
    wg     sync.WaitGroup
    cancel context.CancelFunc
}

func NewTaskScheduler() *TaskScheduler {
    return &TaskScheduler{}
}

func (ts *TaskScheduler) ScheduleTask(ctx context.Context, interval time.Duration, task func()) {
    ts.wg.Add(1)
    
    go func() {
        defer ts.wg.Done()
        
        ticker := time.NewTicker(interval)
        defer ticker.Stop()
        
        for {
            select {
            case <-ticker.C:
                task()
            case <-ctx.Done():
                return
            }
        }
    }()
}

func (ts *TaskScheduler) Stop() {
    if ts.cancel != nil {
        ts.cancel()
    }
    ts.wg.Wait()
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    
    scheduler := NewTaskScheduler()
    scheduler.cancel = cancel
    
    // 调度多个任务
    scheduler.ScheduleTask(ctx, 1*time.Second, func() {
        fmt.Println("任务1:", time.Now().Format("15:04:05"))
    })
    
    scheduler.ScheduleTask(ctx, 2*time.Second, func() {
        fmt.Println("任务2:", time.Now().Format("15:04:05"))
    })
    
    // 运行一段时间后停止所有任务
    time.Sleep(10 * time.Second)
    scheduler.Stop()
    fmt.Println("所有任务已停止")
}

这些方案都避免了简单的time.Sleep循环，提供了更好的控制性和错误处理能力。对于生产环境，推荐使用time.Ticker方案或robfig/cron库，它们都经过了充分测试且无内存泄漏问题。