Golang第三方库robfig/cron定时器库用法小结

格式类型
字段组成（从左到右）
精度
适用场景
标准格式（兼容Unix）
分（0-59）、时（0-23）、日（1-31）、月（1-12）、周（0-6，0为周日）
分钟级
无需秒级精度的定时任务
扩展格式（robfig扩展）
秒（0-59）、分（0-59）、时（0-23）、日（1-31）、月（1-12）、周（0-6）
秒级
需要高精度定时的任务（如每5秒执行一次）

表达式
格式类型
执行频率
`*/5 * * * *`
标准格式
每5分钟执行一次
`0 0 3 * * *`
扩展格式
每天凌晨3点0分0秒执行
`0 30 8 * * 1-5`
标准格式
工作日（周一到周五）早上8点30分执行
`@every 10s`
快捷指令
每10秒执行一次
`@daily`
快捷指令
每天凌晨0点执行（等价于`0 0 0 * * *`）
`@weekly`
快捷指令
每周日凌晨0点执行
⚠️ 注意：快捷指令`@every <duration>`中的时长需符合Golang`time.Duration`格式（如`s`秒、`m`分、`h`时）。

package main

import (
  "fmt"
  "time"

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

// 定义要执行的任务函数
func task() {
  fmt.Printf("Task executed at: %s\n", time.Now().Format("2006-01-02 15:04:05"))
}

func main() {
  // 1. 创建调度器（默认使用本地时区，支持秒级精度）
  c := cron.New(cron.WithSeconds()) // 启用秒级字段，若用标准格式可省略该参数

  // 2. 添加定时任务（表达式：每5秒执行一次）
  // AddFunc参数：Cron表达式、任务函数（无参数、无返回值）
  _, err := c.AddFunc("*/5 * * * * *", task)
  if err != nil {
    fmt.Printf("Failed to add task: %v\n", err)
    return
  }

  // 3. 启动调度器（非阻塞，会启动一个新协程执行任务）
  c.Start()
  fmt.Println("Cron scheduler started. Waiting for tasks...")

  // 阻塞主协程，避免程序退出（实际项目中可结合服务生命周期管理）
  select {}
}

func main() {
  // 加载时区（Asia/Shanghai对应北京时间）
  loc, err := time.LoadLocation("Asia/Shanghai")
  if err != nil {
    fmt.Printf("Failed to load location: %v\n", err)
    return
  }
  // 创建指定时区的调度器（同时启用秒级精度）
  c := cron.New(
    cron.WithSeconds(),
    cron.WithLocation(loc),
  )
  // 添加任务（按北京时间每天凌晨3点执行）
  c.AddFunc("0 0 3 * * *", func() {
    fmt.Printf("Task executed at CST: %s\n", time.Now().Format("2006-01-02 15:04:05"))
  })
  c.Start()
  select {}
}

func main() {
  c := cron.New(cron.WithSeconds())
  // 添加任务并记录ID
  taskID, _ := c.AddFunc("*/10 * * * * *", func() {
    fmt.Println("Dynamic task executed")
  })
  fmt.Printf("Added task with ID: %d\n", taskID)
  c.Start()
  // 30秒后移除任务
  time.AfterFunc(30*time.Second, func() {
    c.Remove(taskID)
    fmt.Printf("Task %d removed\n", taskID)
  })
  // 60秒后停止调度器
  time.AfterFunc(60*time.Second, func() {
    ctx := c.Stop()
    <-ctx.Done() // 等待当前任务执行完成
    fmt.Println("Cron scheduler stopped")
  })
  select {}
}

// 方式1：通过闭包传递参数
func main() {
  c := cron.New(cron.WithSeconds())
  // 带参数的任务逻辑
  taskWithParam := func(name string) func() {
    return func() {
      fmt.Printf("Task %s executed at: %s\n", name, time.Now().Format("2006-01-02 15:04:05"))
    }
  }
  // 添加两个不同参数的任务
  c.AddFunc("*/5 * * * * *", taskWithParam("TaskA"))
  c.AddFunc("*/8 * * * * *", taskWithParam("TaskB"))
  c.Start()
  select {}
}
// 方式2：通过结构体实现（适用于复杂任务）
type Task struct {
  Name string
}
func (t *Task) Run() {
  fmt.Printf("Struct task %s executed at: %s\n", t.Name, time.Now().Format("2006-01-02 15:04:05"))
}
func main() {
  c := cron.New(cron.WithSeconds())
  // AddJob添加实现cron.Job接口的对象（需实现Run()方法）
  c.AddJob("*/5 * * * * *", &Task{Name: "StructTask"})
  c.Start()
  select {}
}

import (
  "fmt"
  "log"
  "time"

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

// 带错误处理的任务
func taskWithError() {
  defer func() {
    if err := recover(); err != nil {
      log.Printf("Task panicked: %v\n", err)
    }
  }()

  // 模拟错误
  fmt.Println("Executing task with error handling...")
  panic("something went wrong")
}

func main() {
  // 配置日志记录（输出调度器状态、任务执行情况）
  logger := cron.VerbosePrintfLogger(log.New(log.Writer(), "CRON: ", log.LstdFlags))
  c := cron.New(
    cron.WithSeconds(),
    cron.WithLogger(logger), // 启用日志
  )

  c.AddFunc("*/10 * * * * *", taskWithError)
  c.Start()

  select {}
}

import (
  "fmt"
  "time"
  "github.com/robfig/cron/v3"
  "github.com/robfig/cron/v3/chain"
)
// 模拟耗时任务（执行时间15秒）
func longRunningTask() {
  fmt.Printf("Long task started at: %s\n", time.Now().Format("2006-01-02 15:04:05"))
  time.Sleep(15 * time.Second)
  fmt.Printf("Long task finished at: %s\n", time.Now().Format("2006-01-02 15:04:05"))
}
func main() {
  // 配置中间件：若任务仍在运行，跳过本次执行
  jobWrapper := chain.SkipIfStillRunning(cron.DefaultLogger)
  c := cron.New(
    cron.WithSeconds(),
    cron.WithChain(jobWrapper), // 应用中间件
  )
  // 每10秒执行一次，但任务耗时15秒，会跳过并发执行的次数
  c.AddFunc("*/10 * * * * *", longRunningTask)
  c.Start()
  select {}
}

package main
import (
  "fmt"
  "log"
  "sync"
  "time"
  "github.com/gin-gonic/gin"
  "github.com/robfig/cron/v3"
)
// 模拟缓存存储
var (
  cache  = make(map[string]string)
  mu     sync.Mutex // 保证缓存操作并发安全
  expire = 5 * time.Minute // 缓存过期时间
)
// 清理过期缓存的任务
func cleanExpiredCache() {
  mu.Lock()
  defer mu.Unlock()
  now := time.Now()
  count := 0
  // 遍历缓存，删除过期数据（实际项目中可给缓存值添加过期时间字段）
  for key := range cache {
    // 模拟过期判断（实际需存储缓存创建时间）
    if now.Sub(time.UnixMilli(0)).Seconds()%300 > 200 {
      delete(cache, key)
      count++
    }
  }
  log.Printf("Cleaned %d expired cache entries at: %s\n", count, now.Format("2006-01-02 15:04:05"))
}
func main() {
  // 1. 初始化定时器，每5分钟清理一次缓存
  c := cron.New(cron.WithSeconds())
  c.AddFunc("0 0 */5 * * *", cleanExpiredCache)
  c.Start()
  defer func() {
    ctx := c.Stop()
    <-ctx.Done()
    log.Println("Cron scheduler stopped")
  }()
  // 2. 初始化Gin
  r := gin.Default()
  // 模拟设置缓存接口
  r.GET("/set-cache", func(c *gin.Context) {
    key := c.Query("key")
    val := c.Query("val")
    if key == "" || val == "" {
      c.JSON(400, gin.H{"error": "key and val are required"})
      return
    }
    mu.Lock()
    cache[key] = val
    mu.Unlock()
    c.JSON(200, gin.H{"msg": "cache set successfully"})
  })
  // 3. 启动Gin服务
  log.Println("Gin server started on :8080")
  if err := r.Run(":8080"); err != nil {
    log.Fatalf("Gin server failed to start: %v", err)
  }
}