go-Cron

最新推荐文章于 2025-07-22 15:54:32 发布

原创最新推荐文章于 2025-07-22 15:54:32 发布 · 375 阅读

0 ·

CC 4.0 BY-SA版权

go-插件专栏收录该内容

97 篇文章

订阅专栏

使用示例

安装下载cron，目前最新的稳定版已经迭代到了v3

go get github.com/robfig/cron/v3@v3.0.0

在项目中导入包

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

使用

package main
 
 import (
     "fmt"
 
     "github.com/robfig/cron/v3"
 )
 
 func main() {
    c := cron.New()
    c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
    c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
    c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
    c.AddFunc("@hourly", func() { fmt.Println("Every hour, starting an hour from now") })
   c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
    c.AddFunc("@every 1s", func() {fmt.Println("Every 1 second, starting an hour thirty from now")})
    c.Start()
    select {}

创建cron对象

使用时，首先通过cron.New()创建cron对象，通过该对象管理定时任务。通过调用cron的AddFunc()方法添加定时任务。AddFun()入参为二，参数一是以字符串的形式指定触发任务规则，参数二是无入参的函数，任务触发时执行函数。

添加触发任务
30 * * * *表示每个小时内的第30分钟时触发；30 3-6,20-23 * * *表示在早上3点到6点，下午8点到11点的第30分钟时触发；*CRON_TZ=Asia/Tokyo 30 04 * * 表示东京时间每天早上4点半触发；@hourly表示从添加该任务时算起的之后每小时触发；@every 1h30m表示从添加该任务时算起的之后每一个半小时触发；@every 1s表示从添加该任务时算起的之后每秒触发。

启动定时循环
通过调用cron.Start()启动定时循环任务。

结果

Every 1 second, starting an hour thirty from now
3Every 1 second, starting an hour thirty from now

cron时间表达式规则

cron表达式默认通过使用5个以空格分隔的字段组合来表示触发时间（和linux的crontab保持一致）。
切记，不加0就会有问题

## 样例

有秒的,
0 53,55 17 * * *   每天17点的53分55秒 
* 53,55 17 * * *  错误样例，这样会到了53之后一直执行---错误的 第一个要是0

无秒的
30 * * * *表示每个小时内的第30分钟时触发
30 3-6,20-23 * * *表示在早上3点到6点下午8点到11点的第30分钟时触发；
* *CRON_TZ=Asia/Tokyo 30 04 * * *表示东京时间每天早上4点半触发；
@hourly表示从添加该任务时算起的之后每小时触发；
@every 1h30m表示从添加该任务时算起的之后每一个半小时触发；
@every 1s表示从添加该任务时算起的之后每秒触发。

 每隔5秒执行一次：
	*/5 * * * * ?

 每隔1分钟执行一次：
0 */1 * * * ?

每天23点执行一次：
0 0 23 * * ?

每天凌晨1点执行一次：
0 0 1 * * ?

每月1号凌晨1点执行一次：
0 0 1 1 * ?

在26分、29分、33分执行一次：
0 26,29,33 * * * ?

每天的0点、13点、18点、21点都执行一次：
0 0 0,13,18,21 * * ?

周一到周六的9点-18点，每隔5分钟执行一次
0 */5 9-18 * * MON-SAT

周一到周六的9点半-18点，每隔5分钟执行一次,包含9点和18点
0 30-59/5 9-18 * * MON-SAT

@hourly 表示从添加该任务时算起的之后每小时触发

@every 1h30m 表示从添加该任务时算起的之后每一个半小时触发；

Field name   | Mandatory? | Allowed values  | Allowed special characters
----------   | ---------- | --------------  | --------------------------
Minutes      | Yes        | 0-59            | * / , -
Hours        | Yes        | 0-23            | * / , -
Day of month | Yes        | 1-31            | * / , - ?
Month        | Yes        | 1-12 or JAN-DEC | * / , -
Day of week  | Yes        | 0-6 or SUN-SAT  | * / , - ?

如同30 * * * *一样，默认第1个字段表示分钟，第2个字段表示小时，第3个字段表示每月中的日期，第4个字段表示月份数，第5个字段表示星期几。

cron还提供了强大的自定义时间格式功能，可以通过调用cron.NewParser()创建自定义Parser对象，例如通过以下方式定义新的cron时间表达式规则

cron.New(
   cron.WithParser(
        cron.NewParser(
            cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))

这样，时间字段一共是7位，第1位就是指定秒。秒执行的时间表达式就可以用1 * * * * * *表示。

因为添加Seconds是对标准cron规范的最常见修改，因此cron提供了一个内置函数cron.WithSeconds()来执行此操作，该函数等效于之前使用的自定义解析器。

cron.New(cron.WithSeconds())

预定义时间表

由于cron的时间表达式可读性不是很好，因此cron库预定义了一些字符串来表示特定的时间规则。

Entry                  | Description                                | Equivalent To
-----                  | -----------                                | -------------
@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
@hourly                | Run once an hour, beginning of hour        | 0 * * * *

月、周对照

months  = bounds{1, 12, map[string]uint{
		"jan": 1,
		"feb": 2,
		"mar": 3,
		"apr": 4,
		"may": 5,
		"jun": 6,
		"jul": 7,
		"aug": 8,
		"sep": 9,
		"oct": 10,
		"nov": 11,
		"dec": 12,
	}}
dow = bounds{0, 6, map[string]uint{
		"sun": 0,
		"mon": 1,
		"tue": 2,
		"wed": 3,
		"thu": 4,
		"fri": 5,
		"sat": 6,
	}}

时间间隔

cron还提供了更具可读性的固定时间间隔格式

@every <duration>

它代码每隔duration触发执行一次任务。这里的duration是通过调用标准库time的ParseDuration()函数解析的，所以只要ParseDuration()支持的格式都能支持。例如上文示例的@every 1h30m和@every 1s。

cron可控选项

在cron源码option.go文件中，暴露了5个函数供开发者控制cron对象的选项。

WithLocation()

指定时区。默认情况下基于当前时区（在Unix系统中，查询TZ环境变量确定要使用的时区，若未定义TZ，则使用/etc/localtime文件中的定义时区）。可通过在时间字符串前添加CRON_TZ=字符串再加上具体的时区。例如东京时区为Asia/Tokyo。

c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })

WithParser()

自定义时间解析器，上文已有示例，这里不再赘述。

WithSeconds()

增加对秒的时间格式支持，其内部调用的WithParser()方法。

func WithSeconds() Option {
    return WithParser(NewParser(
        Second | Minute | Hour | Dom | Month | Dow | Descriptor,
    ))
}

WithChain()

Job包装器，下文中会讲解Job接口

WithLogger()

Logger是cron中用于记录日志的接口，WithLogger()可以设置自定义的Logger。

package main

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

func main() {

	file := "./" + "message" + ".txt"
	logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
	if err != nil {
		panic(err)
	}
	ssd := log.New(logFile, "cron process: ", log.LstdFlags)
	ssd.SetOutput(logFile) // 将文件设置为log输出的文件
	ssd.SetPrefix("[qSkipTool]")
	ssd.SetFlags(log.LstdFlags | log.Lshortfile | log.LUTC)

	c := cron.New(cron.WithLogger(cron.VerbosePrintfLogger(ssd)))
	c.AddFunc("@every 1s", func() { fmt.Println("Every 1 second") })
	c.Start()

	select {}
}

结果

cat message.txt
[qSkipTool]2020/11/13 05:48:28 test1.go:22: Hello Davis!
[qSkipTool]2020/11/13 05:56:21 logger.go:46: start
[qSkipTool]2020/11/13 05:56:21 logger.go:46: schedule, now=2020-11-13T13:56:21+08:00, entry=1, next=2020-11-13T13:56:22+08:00
[qSkipTool]2020/11/13 05:56:22 logger.go:46: wake, now=2020-11-13T13:56:22+08:00
[qSkipTool]2020/11/13 05:56:22 logger.go:46: run, now=2020-11-13T13:56:22+08:00, entry=1, next=2020-11-13T13:56:23+08:00
[qSkipTool]2020/11/13 05:56:23 logger.go:46: wake, now=2020-11-13T13:56:23+08:00
[qSkipTool]2020/11/13 05:56:23 logger.go:46: run, now=2020-11-13T13:56:23+08:00, entry=1, next=2020-11-13T13:56:24+08:00
[qSkipTool]2020/11/13 05:56:24 logger.go:46: wake, now=2020-11-13T13:56:24+08:00
[qSkipTool]2020/11/13 05:56:24 logger.go:46: run, now=2020-11-13T13:56:24+08:00, entry=1, next=2020-11-13T13:56:25+08:00
[qSkipTool]2020/11/13 05:56:25 logger.go:46: wake, now=2020-11-13T13:56:25+08:00
[qSkipTool]2020/11/13 05:56:25 logger.go:46: run, now=2020-11-13T13:56:25+08:00, entry=1, next=2020-11-13T13:56:26+08:00
[qSkipTool]2020/11/13 05:56:26 logger.go:46: wake, now=2020-11-13T13:56:26+08:00
[qSkipTool]2020/11/13 05:56:26 logger.go:46: run, now=2020-11-13T13:56:26+08:00, entry=1, next=2020-11-13T13:56:27+08:00
[qSkipTool]2020/11/13 05:56:27 logger.go:46: wake, now=2020-11-13T13:56:27+08:00

自定义Job

cron中定义了Job接口，对象只要实现了Job接口所定义的Run()方法，均可以调用cron.AddJob()方法将该对象添加到定时管理器中。

// Job is an interface for submitted cron jobs.
type Job interface {
    Run()
}

AddFunc()

在上文示例中，通过cron.AddFunc()方法为cron对象添加定时任务。实质上，AddFunc()方法内部调用的也是AddJob()方法：定义新类型对象FuncJob，为其实现Job接口，在AddFunc()方法中，将回调参数func()转为FuncJob类型，调用AddJob()方法。

type FuncJob func()

func (f FuncJob) Run() { f() }

func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error) {
    return c.AddJob(spec, FuncJob(cmd))
}

自实现Job接口

除了通过AddFunc()将无参函数直接作为回调外，我们还可以通过AddJon()自定义对象。

如下，自定义对象CallJob，实现Run()方法。

package main
 
 import (
     "fmt"
     "time"
 
     "github.com/robfig/cron/v3"
 )
 
type CallJob struct {
    name   string
    number int
}

func (c CallJob) Run() {
    fmt.Printf("call %s : %d\n", c.name, c.number)
}
func main() {
    c := cron.New()
    c.AddJob("@every 1s", CallJob{
        name:   "Bob",
        number: 13888888888,
            })
    c.Start()

    time.Sleep(3 * time.Second)
}

$ go run main.go 
call Bob : 13888888888
call Bob : 13888888888
call Bob : 13888888888