每小时运行后台任务的Golang实现方案

对于在每天特定时间运行后台任务的需求，Go语言中有几种实现方案。以下是两种常用方法：

方案一：使用time.Ticker配合时间计算

package main

import (
    "fmt"
    "time"
)

func scheduleTaskAtSpecificTime(hour, minute, second int) {
    for {
        now := time.Now()
        next := time.Date(
            now.Year(), now.Month(), now.Day(),
            hour, minute, second, 0, now.Location(),
        )
        
        if now.After(next) {
            next = next.Add(24 * time.Hour)
        }
        
        duration := next.Sub(now)
        fmt.Printf("Next execution in: %v\n", duration)
        
        <-time.After(duration)
        
        // 执行任务
        fmt.Printf("Task executed at %s\n", time.Now().Format("15:04:05"))
        
        // 等待一秒钟避免立即重复执行
        time.Sleep(1 * time.Second)
    }
}

func main() {
    // 每小时运行（在每小时的第0分钟第0秒）
    go scheduleTaskAtSpecificTime(0, 0, 0)
    
    // 或者每天午夜运行
    // go scheduleTaskAtSpecificTime(0, 0, 0)
    
    select {}
}

方案二：使用cron表达式（推荐）

使用第三方库如robfig/cron可以更灵活地处理复杂调度：

package main

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

func main() {
    c := cron.New(cron.WithSeconds()) // 支持秒级精度
    
    // 每小时运行（每小时的第0分钟第0秒）
    _, err := c.AddFunc("0 0 * * * *", func() {
        fmt.Printf("Hourly task executed at %s\n", 
            time.Now().Format("2006-01-02 15:04:05"))
    })
    
    if err != nil {
        fmt.Printf("Error adding cron job: %v\n", err)
        return
    }
    
    // 每天午夜运行
    _, err = c.AddFunc("0 0 0 * * *", func() {
        fmt.Printf("Midnight task executed at %s\n", 
            time.Now().Format("2006-01-02 15:04:05"))
    })
    
    // 每5分钟运行
    _, err = c.AddFunc("0 */5 * * * *", func() {
        fmt.Printf("Every 5 minutes task executed at %s\n", 
            time.Now().Format("2006-01-02 15:04:05"))
    })
    
    c.Start()
    
    // 保持主程序运行
    select {}
}

方案三：使用time.Ticker的精确小时调度

package main

import (
    "fmt"
    "time"
)

func hourlyTask() {
    // 计算到下一个整点的时间
    now := time.Now()
    nextHour := now.Truncate(time.Hour).Add(time.Hour)
    duration := nextHour.Sub(now)
    
    fmt.Printf("First execution in: %v\n", duration)
    
    // 等待到下一个整点
    <-time.After(duration)
    
    // 创建每小时触发的ticker
    ticker := time.NewTicker(time.Hour)
    defer ticker.Stop()
    
    for t := range ticker.C {
        fmt.Printf("Hourly task executed at %s\n", 
            t.Format("2006-01-02 15:04:05"))
    }
}

func main() {
    go hourlyTask()
    select {}
}

方案四：带错误处理的完整示例

package main

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

func taskWrapper(taskName string, taskFunc func()) func() {
    return func() {
        start := time.Now()
        fmt.Printf("[%s] Starting at %s\n", 
            taskName, start.Format("15:04:05"))
        
        defer func() {
            if r := recover(); r != nil {
                log.Printf("[%s] Panic recovered: %v", taskName, r)
            }
        }()
        
        taskFunc()
        
        duration := time.Since(start)
        fmt.Printf("[%s] Completed in %v\n", taskName, duration)
    }
}

func main() {
    c := cron.New(
        cron.WithLogger(
            cron.VerbosePrintfLogger(log.New(log.Writer(), 
                "cron: ", log.LstdFlags)),
        ),
    )
    
    // 每小时运行
    c.AddFunc("@hourly", taskWrapper("hourly-task", func() {
        // 实际业务逻辑
        fmt.Println("Processing hourly data...")
        time.Sleep(100 * time.Millisecond) // 模拟任务执行
    }))
    
    // 每天午夜运行
    c.AddFunc("@midnight", taskWrapper("midnight-task", func() {
        fmt.Println("Processing daily reports...")
        time.Sleep(200 * time.Millisecond)
    }))
    
    // 自定义时间：每天10:30运行
    c.AddFunc("0 30 10 * * *", taskWrapper("custom-time", func() {
        fmt.Println("Running at 10:30 AM daily...")
    }))
    
    c.Start()
    
    // 优雅关闭
    defer c.Stop()
    
    select {}
}

安装cron库

go get github.com/robfig/cron/v3

推荐使用robfig/cron方案，它提供了更丰富的调度表达式和更好的错误处理机制，特别适合生产环境使用。