【Golang】定时任务Cron指南-毫秒级任务支持

oofpg2024-02-13 18:01

文章目录

Cron

版本：v3.0.0

仓库：https://github.com/robfig/cron

cron是golang实现定时任务比较好的库, 这个库提供了一个简单而强大的接口，用于创建和管理基于cron表达式的定时任务。cron库的主要特点有：

  • 基于cron表达式的任务调度
  • 多任务支持
  • 容错和错误处理
  • 可靠性
  • 易用的API
  • 灵活性
  • 并发安全

Cron快速使用

go 复制代码 
package main

import (
	"fmt"

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

func main() {
	job := cron.New()

	job.AddFunc("@every 1s", func() {
		fmt.Println("hello world")
	})
	job.Start()
	select {}
}

上述简单的示例表示，每秒钟执行一次hello world 打印。其中容易让人产生困惑的是"@every 1s"的含义，这是一条描述定时任务执行的时间表达式，下面将会具体介绍。

时间表达式

cron库支持用 6 个空格分隔的域来表示时间（在v3版本中新增了对秒级任务的支持）：

# ┌────────────── second (0--59)
# │ ┌───────────── minute (0--59)
# │ │ ┌───────────── hour (0--23)
# │ │ │ ┌───────────── day of the month (1--31)
# │ │ │ │ ┌───────────── month (1--12)
# │ │ │ │ │ ┌───────────── day of the week (0--6) (Sunday to Saturday;
# │ │ │ │ │ │                                   7 is also Sunday on some systems)
# │ │ │ │ │ │
# │ │ │ │ │ │
# * * * * * * <command to execute>

Field name   | Mandatory? | Allowed values  | Allowed special characters
----------   | ---------- | --------------  | --------------------------
Seconds      | Yes        | 0-59            | * / , -
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  | * / , - ?
  • 星号 (*)：星号表示 cron 表达式将匹配该字段的所有值；例如，在第 5 个字段（月份）中使用星号将表示每个月。
  • 斜杠 (/)：斜杠用于描述范围的步长。例如，第2个字段（分钟）中的 3-59/15 表示该小时的第 3 分钟以及此后每 15 分钟一次。
  • 逗号 (,)：逗号用于分隔列表中的项目。例如，在第 6 个字段（星期几）中使用"MON,WED,FRI"将表示星期一、星期三和星期五。
  • 连字符 (-)：连字符用于定义范围。例如，在第 3 个字段（小时）9-17 表示上午 9 点到下午 5 点之间的每小时（含）。
  • 问号(?)：只能用在月和周的域中，用来代替*，表示每月/周的任意一天。

最小分钟级任务

使用这种以空格分隔的域来表示时间的方式默认情况下只能支持到分钟级任务：

go 复制代码 
package main

import (
	"fmt"

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

func main() {
	job := cron.New()

	job.AddFunc("* * * * *", func() {
		fmt.Println("hello world")
	})
	job.Start()
	select {}
}

表示每分钟执行一次

注意：实测在v3.0.1版本6个*是不会执行任务的。

查看表达是是否正确：https://crontab.guru/

最小秒级任务

如果想要支持秒级任务，则需添加cron.WithSeconds选项：

go 复制代码 
package main

import (
	"fmt"

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

func main() {
	job := cron.New()

	job.AddFunc("* * * * * *", func() {
		fmt.Println("hello world")
	})
	job.Start()
	select {}
}

表示每秒执行一次

注意：添加了cron.WithSeconds后6个*可以正确执行。

预定义的时间表

可以使用几个预定义计划之一来代替 cron 表达式。

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

还可以安排作业以固定的时间间隔执行，从添加作业或运行 cron 时开始。这是通过格式化 cron 规范来支持的，如下所示：

@every <duration>

其中"duration"是 time.ParseDuration 接受的字符串（http://golang.org/pkg/time/#ParseDuration）

例子：

go 复制代码 
c := cron.New()
c.AddFunc("@hourly",      func() { fmt.Println("Every hour") })
c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty") })
c.AddFunc("@every 1s", func() { fmt.Println("Every seconds") })
c.Start()

cron还提供了cron.Every方法，用于直接接收time.Duration来设置任务间隔：

go 复制代码 
package main

import (
	"fmt"
	"time"

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

func main() {
	job := cron.New(cron.WithSeconds())

	job.Schedule(cron.Every(1*time.Second), cron.FuncJob(func() {
		fmt.Println("hello world")
	}))
	job.Start()
	select {}
}

时区

默认情况下任务是基于当前时区的，cron也可以设置不同的时区:

go 复制代码 
loLosAngeles, _ := time.LoadLocation("America/Los_Angeles")
job := cron.New(cron.WithLocation(loLosAngeles))
job.AddFunc("0 6 * * ?", func() {
	fmt.Println("Every 6 o'clock at Los Angeles")
})

或者：

go 复制代码 
job.AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", func() {
  fmt.Println("Every 6 o'clock at Tokyo")
})

Job

除了使用无参的回调方式，cron还提供了实现job接口的方式：

go 复制代码 
type Job interface {
	Run()
}

实现job接口

go 复制代码 
package main

import (
	"fmt"
	"time"

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

func main() {
	job := cron.New(cron.WithSeconds())

	j := &myJob{}
	job.AddJob("@every 1s", j)
	job.Start()
	select {}
}

type myJob struct {
	i int
}

func (j *myJob) Run() {
	j.i++
	fmt.Println("hello world:", j.i)
}

执行结果：

shell 复制代码 
hello world: 1
hello world: 2
hello world: 3
hello world: 4
hello world: 5
hello world: 6

选项

  • WithLocation：指定时区
  • WithParser：使用自定义的解析器
  • WithSeconds：让时间格式支持秒
  • WithLogger：自定义日志
  • WithChain：Job 包装器

Job 包装器

Job 包装器可以在执行实际的Job前后添加一些逻辑

cron库提供了一些常用的包装器：

  • cron.DelayIfStillRunning: 如果上周期的任务还在执行，则延迟此次并产生一条Info日志
  • cron.SkipIfStillRunning：如果上周期的任务还在执行，则跳过此次并产生一条Info日志
  • cron.Recover：捕获任务异常，并产生error日志

WithLogger

cron提供默认的标准输出日志打印cron.DefaultLogger和丢弃日志cron.DiscardLogger两种：

go 复制代码 
// DefaultLogger is used by Cron if none is specified.
var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))

// DiscardLogger can be used by callers to discard all log messages.
var DiscardLogger Logger = PrintfLogger(log.New(ioutil.Discard, "", 0))

也可是使用cron.PrintfLogger和cron.VerbosePrintfLogger包装：

  • cron.PrintfLogger: 只打印错误日志
  • cron.VerbosePrintfLogger：打印详细日志
go 复制代码 
package main

import (
	"fmt"

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

func main() {
	job := cron.New(
		cron.WithLogger(cron.VerbosePrintfLogger(
			log.New(os.Stdout, "cron: ", log.LstdFlags),
		)),
	)

	job.AddFunc("@every 1s", func() {
		fmt.Println("hello world")
	})
	job.Start()
	select {}
}

支持毫秒级任务

cron库给出的方法最小只能支持到秒级任务，如果想要精确到毫秒级任务，则需要重新实现Schedule接口

go 复制代码 
// Schedule describes a job's duty cycle.
type Schedule interface {
	// Next returns the next activation time, later than the given time.
	// Next is invoked initially, and then each time the job is run.
	Next(time.Time) time.Time
}

自定义一个ConstantDelaySchedule结构体，并给出Every方法（这边我限制最小到200ms）

go 复制代码 
package cron

import "time"

// ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes".
// It does not support jobs more frequent than once a second.
type ConstantDelaySchedule struct {
	Delay time.Duration
}

// Every returns a crontab Schedule that activates once every duration.
// Delays of less than a second are not supported (will round up to 1 second).
// Any fields less than a Second are truncated.
func Every(duration time.Duration) ConstantDelaySchedule {
	min := 200 * time.Millisecond
	if duration < min {
		duration = min
	}
	return ConstantDelaySchedule{
		Delay: duration,
	}
}

// Next returns the next time this should be run.
// This rounds so that the next activation time will be on the second.
func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
	return t.Add(schedule.Delay)
}

调用：

go 复制代码 
package main

import (
	"fmt"
	"time"

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

func main() {
	job := cron.New(cron.WithSeconds())

	j := &myJob{
		t: time.Now(),
	}
	job.Schedule(Every(200*time.Millisecond), j)
	job.Start()
	select {}
}

type myJob struct {
	i int
	t time.Time
}

func (j *myJob) Run() {
	j.i++
	now := time.Now()
	sub := now.Sub(j.t)
	j.t = now

	fmt.Printf("hello world: %d, duraction : %d ms \n", j.i, sub.Milliseconds())
}

结果：

shell 复制代码 
hello world: 1, duraction : 201 ms 
hello world: 2, duraction : 201 ms 
hello world: 3, duraction : 201 ms 
hello world: 4, duraction : 201 ms 
hello world: 5, duraction : 201 ms 
hello world: 6, duraction : 200 ms 
hello world: 7, duraction : 201 ms 
hello world: 8, duraction : 201 ms 
hello world: 9, duraction : 201 ms
相关推荐
tyler_download3 小时前
golang 实现比特币内核:处理椭圆曲线中的天文数字
golang·blockchain·bitcoin
疯狂的程需猿4 小时前
一个百度、必应搜索引擎图片获取下载的工具包
golang·图搜索
明月看潮生5 小时前
青少年编程与数学 02-003 Go语言网络编程 09课题、Cookie
青少年编程·golang·网络编程·编程与数学
明月看潮生6 小时前
青少年编程与数学 02-003 Go语言网络编程 15课题、Go语言URL编程
开发语言·网络·青少年编程·golang·编程与数学
明月看潮生6 小时前
青少年编程与数学 02-003 Go语言网络编程 14课题、Go语言Udp编程
青少年编程·golang·网络编程·编程与数学
hlsd#7 小时前
go 集成go-redis 缓存操作
redis·缓存·golang
funnyZpC17 小时前
quartz集群增强版🎉
java·分布式·开源·集群·定时任务
qq_1728055920 小时前
GIN 反向代理功能
后端·golang·go
__AtYou__21 小时前
Golang | Leetcode Golang题解之第535题TinyURL的加密与解密
leetcode·golang·题解
kevin_tech1 天前
Go API 多种响应的规范化处理和简化策略
开发语言·后端·golang·状态模式
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解