如何让Go的robfig/cron定时任务不受重启影响？指定起始时间

你遇到的是robfig/cron的默认行为：它会以程序启动时间为基准计算下一次任务执行时间，导致重启后任务周期跟着偏移。下面是几个能彻底解决这个问题的方案：

方案1：固定起始时间，强制按原始周期执行 #

如果你的任务必须从某个特定时间（比如2024-01-01）开始，每5天执行一次，不管程序什么时候重启，都严格遵循这个周期，那可以自定义一个调度规则（实现cron.Schedule接口），完全脱离启动时间的依赖。

代码示例：

package main

import (
	"fmt"
	"time"

	"github.com/robfig/cron/v3"
)

// FixedStartSchedule 基于固定起始点的间隔调度器
type FixedStartSchedule struct {
	start time.Time   // 任务的原始起始时间
	step  time.Duration // 执行间隔
}

// Next 计算下一次执行时间，忽略当前程序启动时间
func (s FixedStartSchedule) Next(now time.Time) time.Time {
	// 如果当前时间早于起始时间，直接返回起始时间
	if now.Before(s.start) {
		return s.start
	}

	// 计算从起始时间到现在的总时长，除以间隔得到已完成的周期数
	diff := now.Sub(s.start)
	cycles := diff / s.step
	next := s.start.Add((cycles + 1) * s.step)

	// 防止刚好卡在周期点上，导致重复执行
	if next.Before(now) || next.Equal(now) {
		next = next.Add(s.step)
	}
	return next
}

func main() {
	// 设置你想要的原始起始时间
	originStart, _ := time.Parse("2006-01-02", "2024-01-01")
	// 5天间隔
	fiveDays := 5 * 24 * time.Hour

	c := cron.New()
	// 添加自定义调度的任务
	_, err := c.AddJob(&FixedStartSchedule{start: originStart, step: fiveDays}, cron.FuncJob(func() {
		fmt.Printf("任务执行：%s\n", time.Now().Format("2024-01-02 15:04:05"))
	}))
	if err != nil {
		fmt.Println("添加任务失败：", err)
		return
	}

	c.Start()
	defer c.Stop()

	// 阻塞程序运行
	select {}
}

不管你是1月1号启动还是1月2号重启，任务都会在1月6号、11号、16号这些时间点执行，完全不受重启影响。

方案2：持久化上次执行时间，重启后续接执行 #

如果你的需求是“上次执行完之后再过5天执行”（而非固定起始点），那可以把每次任务的执行时间存在文件或数据库里，重启时读取这个时间，计算下一次应该执行的点，甚至还能补执行遗漏的任务。

代码示例（用本地文件存储上次执行时间）：

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/robfig/cron/v3"
)

const recordFile = "task_last_run.json"

// 读取上次执行时间，首次运行则返回默认起始点
func getLastRunTime() (time.Time, error) {
	file, err := os.Open(recordFile)
	if err != nil {
		if os.IsNotExist(err) {
			return time.Parse("2006-01-02", "2024-01-01")
		}
		return time.Time{}, err
	}
	defer file.Close()

	var lastRun time.Time
	err = json.NewDecoder(file).Decode(&lastRun)
	return lastRun, err
}

// 保存本次执行时间到文件
func saveLastRunTime(t time.Time) error {
	file, err := os.Create(recordFile)
	if err != nil {
		return err
	}
	defer file.Close()
	return json.NewEncoder(file).Encode(t)
}

func main() {
	lastRun, err := getLastRunTime()
	if err != nil {
		fmt.Println("读取执行记录失败：", err)
		return
	}

	interval := 5 * 24 * time.Hour
	c := cron.New()

	// 添加固定间隔任务，每次执行后保存时间
	_, err = c.AddJob(cron.FixedDelaySchedule{Delay: interval}, cron.FuncJob(func() {
		now := time.Now()
		fmt.Printf("任务执行：%s\n", now.Format("2024-01-02 15:04:05"))
		if err := saveLastRunTime(now); err != nil {
			fmt.Println("保存执行记录失败：", err)
		}
	}))
	if err != nil {
		fmt.Println("添加任务失败：", err)
		return
	}

	// 启动时检查是否需要补执行：如果当前时间已经超过上次执行+间隔，立即跑一次
	shouldRunAt := lastRun.Add(interval)
	if time.Now().After(shouldRunAt) {
		go func() {
			now := time.Now()
			fmt.Printf("补执行遗漏任务：%s\n", now.Format("2024-01-02 15:04:05"))
			saveLastRunTime(now)
		}()
	}

	c.Start()
	defer c.Stop()

	select {}
}

这个方案适合需要严格连续间隔的场景，重启后不会丢任务，也不会打乱周期。

方案3：用固定日期的cron表达式（仅适合日历对齐场景） #

如果你的任务不需要严格的5天间隔，只是想每月的1、6、11、16...号执行，可以直接修改cron表达式为：

0 0 0 1,6,11,16,21,26 * ?

这样不管程序什么时候启动，都会匹配这些固定日期，不会因重启偏移。但要注意：这种方式和“每5天”有细微差别，比如1月26号之后下一次是2月1号（间隔6天），如果跨月天数不足会自动跳到下月，需要根据你的实际需求选择。

内容的提问来源于stack exchange，提问作者Go Uii