【Golang】对cron进行二次封装实现指定时间执行定时任务

于 2024-10-08 17:41:05 发布
阅读量437 收藏 8
点赞数 12
分类专栏： Golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45795794/article/details/142762904
版权

目录

1、背景

go中常用的定时任务库：https://github.com/robfig/cron，不支持指定某个时间开始执行一次任务，然后再以一定的时间间隔开始执行任务。在真实的业务场景中可能会有这样的需求：进行某个操作时执行一次任务，然后根据这个操作时间每隔一段时间执行一次任务；再次操作时，立即执行一次任务，然后根据此次操作的时间点每隔一段时间执行一次任务，这时就需要停止上一次操作产生的定时间隔执行任务。下面就根据go中的cron库进行封装来满足上述场景的功能。

2、cron库下载

go get -u github.com/robfig/cron/v3

3、代码示例

【1】结构体定义

import (
	"fmt"
	"sync"
	"time"

	"GoTest/comm/logger"

	"github.com/robfig/cron/v3"
	"go.uber.org/zap"
)

const (
	HOUR   = 1
	MINUTE = 2
	SECOND = 3
)

const defaultIntervalTime = 8

type VarCron struct {
	c            *cron.Cron
	jobId        cron.EntryID //执行的任务id
	jobMutex     sync.Mutex   //防止并发问题
	startTime    time.Time    //定时任务从此时间开始执行
	intervalTime uint32       //任务执行间隔时间,不设置默认8小时
	intervalType uint8        //任务执行间隔类型，1-时，2.分，3-秒,不设置默认单位为时
	f            func() error //要执行的任务
}

type OpOption func(*VarCron)

func NewVarCron(f func() error, opts ...OpOption) *VarCron {
	vc := &VarCron{
		c: cron.New(cron.WithSeconds()), //支持秒级调度
		f: f,
	}

	for _, opt := range opts {
		opt(vc)
	}

	return vc
}

func WithIntervalTime(intervalTime uint32) OpOption {
	return func(vc *VarCron) {
		vc.intervalTime = intervalTime
	}
}

func WithIntervalType(intervalType uint8) OpOption {
	return func(vc *VarCron) {
		vc.intervalType = intervalType
	}
}

上面定义一个新的结构体VarCron就是给原生的cron对象增加一些新的属性字段。

字段含义
jobId定时执行任务的id，只支持一个任务，目的是为了方便管理，如果想支持多个，可以多使用NewVarCron初始化多个对象分别执行各自的定时任务
jobMutex保证并发安全
startTime首次执行任务的时间
intervalTime定时任务执行间隔
intervalType定时任务执行类型
f定时任务中执行的函数

【2】定时任务开启

func (v *VarCron) Start(startTime time.Time) {
	v.jobMutex.Lock() //保证同一时刻只有一个在执行
	defer v.jobMutex.Unlock()

	logger.Info("start var cron", zap.Time("last_start_time", v.startTime), zap.Time("this_start_time", startTime))

	//更新开始时间
	v.startTime = startTime

	//停止上一次的定时任务
	v.stop()

	now := time.Now()
	if now.After(v.startTime) || now.Equal(v.startTime) { //定时任务指定的执行时间在此刻之前就立即执行
		logger.Info("now time after or equal start time", zap.Time("now_time", now), zap.Time("start_time", v.startTime))

		//立即执行一次
		v.execJob()

		//间隔执行定时任务
		jobId, err := v.c.AddFunc(v.getInterval(), func() {
			v.execJob()
		})
		if err != nil {
			logger.Error("add func error", zap.Error(err))
			return
		}

		v.jobId = jobId

		//开始定时任务
		v.c.Start()
	} else {
		logger.Info("now time before start time", zap.Time("now_time", now), zap.Time("start_time", v.startTime))

		//到指定时间时间之后再开始执行定时任务,精确到某月某天某时某分某秒就行
		jobId, err := v.c.AddFunc(fmt.Sprintf("%d %d %d %d %d ?", v.startTime.Second(), v.startTime.Minute(), v.startTime.Hour(), v.startTime.Day(), v.startTime.Month()), func() {
			//停止上一次的定时任务
			v.stop()

			//这次是到指定时间之后的执行
			v.execJob()

			//根据间隔开启定时任务
			newJobId, err := v.c.AddFunc(v.getInterval(), func() {
				v.execJob()
			})
			if err != nil {
				logger.Error("add func error", zap.Error(err))
				return
			}

			v.jobId = newJobId
			v.c.Start()
		})
		if err != nil {
			logger.Error("add func error", zap.Error(err))
			return
		}

		v.jobId = jobId
		v.c.Start()
	}
}

func (v *VarCron) stop() {
	if v.c != nil {
		v.c.Remove(v.jobId) //移除任务
		v.c.Stop()          //关闭定时任务
	}
}

func (v *VarCron) execJob() {
	if err := v.f(); err != nil {
		logger.Error("exec job error", zap.Error(err))
	}
}

func (v *VarCron) getInterval() string {
	if v.intervalTime == 0 {
		v.intervalTime = defaultIntervalTime
	}

	switch v.intervalType {
	case HOUR:
		return fmt.Sprintf("@every %dh", v.intervalTime)
	case MINUTE:
		return fmt.Sprintf("@every %dm", v.intervalTime)
	case SECOND:
		return fmt.Sprintf("@every %ds", v.intervalTime)
	}

	return fmt.Sprintf("@every %dh", v.intervalTime)
}

调用Start(startTime time.Time)函数会有两种场景：

场景1：startTime在当前时间之前，这个时候会立即执行一次任务，然后按照间隔定时执行任务。
场景2：startTime在当前时间之后，这个时候会等待时间到达startTime执行一次，然后按照间隔定时执行任务。

上面代码中的stop函数目的就是为了停止上一次的任务，保证不会有冲突的定时任务执行。

【3】使用示例

f := func() error {
		logger.Info("exec task")

		return nil
	}

	//每30秒打印一次时间
	varCron := self_cron.NewVarCron(f, self_cron.WithIntervalType(self_cron.SECOND), self_cron.WithIntervalTime(30))

	fmt.Println("===== 指定开始时间在当前时间之前,会立即执行一次，然后定时执行 ======")
	varCron.Start(time.Now().AddDate(0, 0, -1)) //AddDate(0, 0, -1)的作用是将日期向前推一天

	time.Sleep(3 * time.Minute) //第一种场景定时执行任务跑三分钟

	fmt.Println("===== 指定开始时间在当前时间之后,到指定时间执行一次，然后再开始定时执行 ======")
	varCron.Start(time.Now().Add(time.Minute)) //一分钟后立即执行一次，然后开始定时执行

	time.Sleep(3 * time.Minute) //第二种场景定时执行任务跑三分钟就退出

上面是一个简单使用的例子：注册一个每隔30秒打印字符串exec task的函数；第1次指定开始时间为昨天的这个时刻，这时会立即打印exec task一次，然后每隔30s打印一次exec task；3分钟后第2次指定开始时间为当前时间的1分钟之后，这时上一次的任务已经被取消，1分钟内不会再打印exec task，1分钟后会打印exec task，然后每隔30s打印一次exec task。

【4】控制台输出

$ go run ./cron_demo/main.go
===== 指定开始时间在当前时间之前,会立即执行一次，然后定时执行 ======
[2024-10-08 17:23:38.135] | INFO | Goroutine:1  | [self_cron/start_cron.go:63] | start var cron | {"last_start_time": "[0001-01-01 00:00:00.000]", "this_start_time": "[2024-10-07 17:23:38.096]"}
[2024-10-08 17:23:38.136] | INFO | Goroutine:1  | [self_cron/start_cron.go:73] | now time after or equal start time | {"now_time": "[2024-10-08 17:23:38.136]", "start_time": "[2024-10-07 17:23:38.096]"}
[2024-10-08 17:23:38.136] | INFO | Goroutine:1  | [cron_demo/main.go:159]      | exec task //指定的执行时间在当前时间之前,立即执行一次,之后每隔30s执行
[2024-10-08 17:24:08.013] | INFO | Goroutine:34 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:24:38.008] | INFO | Goroutine:35 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:25:08.010] | INFO | Goroutine:36 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:25:38.008] | INFO | Goroutine:37 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:26:08.015] | INFO | Goroutine:38 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:26:38.005] | INFO | Goroutine:39 | [cron_demo/main.go:159]      | exec task
===== 指定开始时间在当前时间之后,到指定时间执行一次，然后再开始定时执行 ======
[2024-10-08 17:26:38.144] | INFO | Goroutine:1  | [self_cron/start_cron.go:63] | start var cron | {"last_start_time": "[2024-10-07 17:23:38.096]", "this_start_time": "[2024-10-08 17:27:38.144]"} 
[2024-10-08 17:26:38.145] | INFO | Goroutine:1  | [self_cron/start_cron.go:92] | now time before start time | {"now_time": "[2024-10-08 17:26:38.145]", "start_time": "[2024-10-08 17:27:38.144]"}
[2024-10-08 17:27:38.003] | INFO | Goroutine:5  | [cron_demo/main.go:159]      | exec task //指定时间到了之后才执行,之后每隔30s执行
[2024-10-08 17:28:08.007] | INFO | Goroutine:42 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:28:38.008] | INFO | Goroutine:43 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:29:08.013] | INFO | Goroutine:44 | [cron_demo/main.go:159]      | exec task
[2024-10-08 17:29:38.013] | INFO | Goroutine:45 | [cron_demo/main.go:159]      | exec task

4、总结

上面给出一个指定一个时间开始执行任务，然后再以一定的时间间隔定时执行任务的功能，可以根据业务场景的需求去修改上述功能，新增一些属性，比如除了动态修改定时任务时间，还可以动态修改时间间隔或执行函数，或者新增一个tag字段打印在日志中来区分不同的业务。

在成都搬砖的鸭鸭
关注
专栏目录
golang 定时任务 cron 项目实操
LoganPython的博客
07-14 5917
golang cron 多任务 AddJob
Golang 定时任务 github/robfig/cron/v3 使用与源码解析
热门推荐
面向对象的笔记
02-18 2万+
Cron 源码阅读 robfig/cron/v3 是一个 Golang 的定时任务库，支持 cron 表达式。Cron 的源码真实教科书级别的存在（可能是我菜 …）,真的把低耦合高内聚体现地淋漓尽致，另外其中涉及的装饰器模式，并发处理等都很值得学习。 使用 cron 可以很方便的实现一个定时任务，如下： go get github.com/robfig/cron/v3@v3.0.0 package main import "github.com/robfig/cron/v3" c := cron.N
golang 定时任务处理
molaifeng的专栏
03-31 6377
在 golang 中若写定时脚本，有两种实现。 一、基于原生语法组装 func DocSyncTaskCronJob() { ticker := time.NewTicker(time.Minute * 5) // 每分钟执行一次 for range ticker.C { ProcTask() } } func ProcTask() { log.Println("hello world") } 二、基于 github 中封装的 cron 库实现 package task import (
Go Cron 定时任务
Since
05-14 1238
原文地址：http://zero-tt.fun/go/cron/ 说起 Go 的定时任务，不得不学习一波 robfig/cron 包，github地址 1. 使用 Demo 1.1 每秒钟执行一次 package main import ( "fmt" "time" "github.com/robfig/cron/v3" ) func main() { job := cron.New( cron.WithSeconds(), // 添加秒级别支持，默.
golang自定义cron任务
hell_world!
10-10 1741
需要注意一点的cron.v3(gopkg.in/robfig/cron.v3)和cron(github.com/robfig/cron)的使用完全不同，linux风格的表达式：0 12 * * *，表示每天12点执行一次，在cron里会被补全成0 0 12 * * *，而在cron.v3里会被补全成0 12 * * * *，相当于向左挪了一位，把『时』挪到了『分』，会出问题，这个坑我踩过。 ...
go第三方库文档 定时任务cron
liao__ran的博客
11-22 980
//go第三方库文档 定时任务cron // https://pkg.go.dev/github.com/robfig/cron/v3 // 安装 // 要下载特定的标记版本，请运行： go get github.com/robfig/cron/v3@v3.0.0 // 将其作为以下内容导入程序： import "github.com/robfig/cron/v3" // 由于使用Go模块，它需要Go 1.11或更高版本。 // 用法 // 调用方可以注册要在给定计划中调用的FUNC。Cron将在他..
cron按时间格式触发器(二)
ysir86com的专栏
01-10 1916
上一篇中实现了延迟触发器，开发过程中还有另外一种按照日期触发的需求，例如： 注意： 需要用到上一篇文章中的Job接口 1、每天晚上8点开始某个活动 2、每整点执行某些操作等 首先我们要用到cron格式解析，对应git地址 https://github.com/rfyiamcool/cronlib cron表达式生成器 下面是直接搬家的cronlib源代码 package tim...
【GoLand】GoLand定时任务 github/robfig/cron/v3 使用与源码解析
AloneYueCSDN
04-10 2895
文章目录Cron 源码阅读源码概览1.核心数据结构和接口type Entry tructtype Cron structinterface2.对接口的实现ScheduleParser 的实现Schedule 的实现Job 的实现总结New()AddFunc()Entries() 和 Entry()Remove()Stop()Start()对 timer.C 的处理对 c.add 的处理对 c.snapshot 的处理对 c.stop 的处理对 c.remove 的处理OptionWithLocationWi
Go 定时任务
qq_39335595的博客
04-25 221
【代码】Go定时任务。
Go 每日一库之 cron
darjun的博客
06-27 769
简介 cron一个用于管理定时任务的库，用 Go 实现 Linux 中crontab这个命令的效果。之前我们也介绍过一个类似的 Go 库——gron。gron代码小巧，用于学习是比较好的。但是它功能相对简单些，并且已经不维护了。如果有定时任务需求，还是建议使用cron。 快速使用 文本代码使用 Go Modules。 创建目录并初始化： $ mkdir cron && cd cron $ go mod init github.com/darjun/go-daily-lib/cron 安装c
Go语言开发Web应用实战——这本书介绍了如何用Golang开发Web应用，涵盖从基础概念到实践应用等内容
AI天才研究院
07-29 1270
2019年是第四个十年科技革命的开端，也是Golang被广泛应用的一个年份。这几年，Golang的热度不断提升，在开源社区及企业内部也出现了一批拥抱Go的优秀人员。每当我听到有人宣传“Golang开发更快、更安全、更高效”，或者推荐“Go语言入门”时，都会觉得不可思议。Golang作为新一代的编程语言，非常适合用来开发复杂的分布式系统，但同时它也非常简单易懂，可以轻松地学习掌握。在本书中，你将从零开始构建一个完整的基于Golang+Vue.js+MySQL Web应用程序。
Golang | Leetcode Golang题解之第447题回旋镖的数量
weixin_66442839的博客
09-30 477
Golang | Leetcode Golang题解之第447题回旋镖的数量
mysql设置表的某一个字段每天定时清零
GoppViper的博客
10-04 909
这里的STARTS指定了事件开始的时间，‘2024 - 10 - 05 00:00:00’ 是一个示例时间，表示从 2024 年 10 月 5 日开始执行这个每天一次的操作。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。2.检查和开启事件调度器（如果尚未开启）
go基础面试题汇总第一弹
weixin_43683432的博客
10-01 942
通常作为程序执行前包的初始化，例如mysql redis 等中间件的初始化。
go语言&protoc的详细用法与例子
ruanjianxueyuan113的博客
10-04 523
讲解protoc怎么把某一个目录上的proto文件转成指定目录上的go文件，
Golang | Leetcode Golang题解之第461题汉明距离
最新发布
weixin_66442839的博客
10-07 308
Golang | Leetcode Golang题解之第461题汉明距离
golang rpc
weixin_44575660的博客
10-01 1298
RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务，对应rpc的是本地过程调用，函数调用是最常用的本地过程调用，将本地过程调用变成远程调用会面临着各种问题。函数调用过程：（1）将1和2压入函数的栈中（2）进入add函数，从栈中取出1和2分别赋值给a和b（3）执行a+b将结果压栈（4）将栈中的结果取出打印1.原本的本地函数放到另外一个服务器上去运行，但是引入了很多新问题2.Call的id映射。
Golang 进阶1 —— 面向对象
weixin_41835324的博客
10-06 725
Age int// 实例创建：方式1stu1.Name = "张三"stu1.School = "清华大学"// 实例创建：方式2Name: "李四",Age: 19,School: "北京大学"}// 实例创建：方式3// stu3 是指针(指向的是地址)， 应该给这个地址所指向的对象进行赋值操作(*stu3).Name = "王五"(*stu3).School = "北京大学"// 实例创建：方式4Name: "赵六",Age: 21,School: "北京大学"}
golang gin cron 定时每天三点执行代码 麻烦提供封装好的代码
03-27
以下是使用Gin和Cron进行每天三点执行的示例代码： ```go package main import ( "fmt" "time" "github.com/gin-gonic/gin" "github.com/robfig/cron/v3" ) func main() { router := gin.Default() // 定义cron任务 c := cron.New() c.AddFunc("0 0 3 * * *", func() { fmt.Println("执行代码...") // 在此处添加要执行的代码 }) c.Start() router.Run(":8080") // 等待程序退出 for { time.Sleep(time.Second) } } ``` 在上面的代码中，我们使用`cron`包创建了一个每天三点执行的任务。在任务函数中，我们可以添加要执行的代码。请注意，程序必须保持运行状态以使cron任务得以执行。在这个例子中，我们使用了一个无限循环来保持程序的运行状态，但在实际应用中，你可能需要使用其他方法来保持程序的运行状态。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值