Go语言封装一个Cron定时任务管理器_Golang

介绍

在现代应用中，定时任务是非常常见的需求，无论是用于定时清理数据、定时发送邮件，还是定时执行系统维护任务。go语言作为一门现代编程语言，提供了多种方法来实现定时任务。本文将重点介绍如何在go中封装一个cron定时任务管理器，帮助开发者高效管理定时任务。

目标

我们将通过使用 github.com/robfig/cron/v3 库来实现一个简洁、灵活的定时任务调度器。该库支持基于 cron 表达式的任务调度，我们将基于该库封装出一个简单的 api，供开发者在实际项目中使用。

项目背景

cron 表达式是一种用来表示时间计划的格式，它通常由 5 或 6 个字段组成，表示一个特定的时间点或时间间隔。go中的 robfig/cron 库提供了非常便利的接口来处理这些表达式，并能够定期执行任务。

我们的目标是封装一个 crontab 结构体，它将管理所有的定时任务，支持任务的添加、删除、查询以及启动和停止功能。

代码分析

下面是一个简单的 cron 定时任务调度器的封装代码。它基于 robfig/cron 库并扩展了一个 crontab 结构体，提供了一些常用的操作方法。

代码实现

package crontab

import (
	"github.com/pkg/errors"
	cron "github.com/robfig/cron/v3"
	"sync"
)

// crontab crontab struct
type crontab struct {
	inner *cron.cron
	ids   map[string]cron.entryid
	mutex *sync.rwmutex
}

// newcrontab new crontab
func newcrontab() *crontab {
	return &crontab{
		inner: cron.new(cron.withseconds()), // 支持秒级别的cron表达式
		ids:   make(map[string]cron.entryid),
		mutex: new(sync.rwmutex),
	}
}

// ids 获取所有有效的cron任务id
func (c *crontab) ids() []string {
	c.mutex.rlock()
	defer c.mutex.runlock()

	validids := make([]string, 0, len(c.ids))
	invalidids := make([]string, 0)
	for sid, eid := range c.ids {
		if e := c.inner.entry(eid); e.id != eid {
			invalidids = append(invalidids, sid)
			continue
		}
		validids = append(validids, sid)
	}

	// 清理无效的任务id
	for _, id := range invalidids {
		delete(c.ids, id)
	}

	return validids
}

// start 启动定时任务调度器
func (c *crontab) start() {
	c.inner.start()
}

// stop 停止定时任务调度器
func (c *crontab) stop() {
	c.inner.stop()
}

// delbyid 根据id删除定时任务
func (c *crontab) delbyid(id string) error {
	c.mutex.lock()
	defer c.mutex.unlock()

	eid, ok := c.ids[id]
	if !ok {
		return errors.errorf("crontab id not exists!")
	}
	c.inner.remove(eid)
	delete(c.ids, id)

	return nil
}

// addbyid 根据id添加定时任务
// spec 是cron表达式，cmd 是执行的任务
func (c *crontab) addbyid(id, spec string, cmd cron.job) error {
	c.mutex.lock()
	defer c.mutex.unlock()

	if _, ok := c.ids[id]; ok {
		return errors.errorf("crontab id exists!")
	}
	eid, err := c.inner.addjob(spec, cmd)
	if err != nil {
		return err
	}
	c.ids[id] = eid
	return nil
}

// addbyfunc 根据id添加函数作为定时任务
func (c *crontab) addbyfunc(id, spec string, f func()) error {
	c.mutex.lock()
	defer c.mutex.unlock()

	if _, ok := c.ids[id]; ok {
		return errors.errorf("crontab id exists!")
	}
	eid, err := c.inner.addfunc(spec, f)
	if err != nil {
		return err
	}
	c.ids[id] = eid
	return nil
}

// isexists 判断某个任务id是否已存在
func (c *crontab) isexists(jid string) bool {
	c.mutex.rlock()
	defer c.mutex.runlock()

	_, exist := c.ids[jid]
	return exist
}

主要功能

newcrontab(): 初始化一个新的 crontab 实例，内部使用 cron.new() 来创建一个 cron 调度器，支持秒级别的 cron 表达式。

ids(): 获取当前所有有效的定时任务id。会清理掉无效的任务id。

start(): 启动 cron 调度器，开始执行所有的定时任务。

stop(): 停止 cron 调度器，暂停定时任务的执行。

delbyid(id): 根据任务id删除定时任务。

addbyid(id, spec, cmd): 根据 cron 表达式添加一个新的定时任务。任务id必须唯一。

addbyfunc(id, spec, f): 将一个函数作为定时任务来添加，使用 cron 表达式来指定执行频率。

isexists(jid): 判断某个定时任务id是否存在。

cron表达式解析

cron 表达式是定时任务调度中常见的表示方式，它由五个或六个字段组成，每个字段代表一个时间单位。标准的 cron 表达式格式如下：

* * * * * *
│ │ │ │ │ │
│ │ │ │ │ └─ 星期几 (0 - 7) (0或7代表星期天)
│ │ │ │ └──── 月份 (1 - 12)
│ │ │ └────── 日 (1 - 31)
│ │ └──────── 小时 (0 - 23)
│ └────────── 分钟 (0 - 59)
└──────────── 秒 (0 - 59)

例子

* * * * * *：每秒执行一次任务
0 * * * * *：每分钟的第0秒执行一次任务
0 0 * * * *：每天午夜执行一次任务
0 0 1 * * *：每月的第一天执行一次任务

使用示例

以下是如何使用封装好的 crontab 类型来管理定时任务的示例：

package main

import (
	"fmt"
	"github.com/robfig/cron/v3"
	"time"
	"your_project/crontab"
)

func main() {
	// 创建一个新的 crontab 实例
	c := crontab.newcrontab()

	// 定义一个定时任务
	task := func() {
		fmt.println("task executed at", time.now())
	}

	// 添加定时任务
	err := c.addbyfunc("task1", "*/5 * * * * *", task) // 每5秒执行一次
	if err != nil {
		fmt.println("error adding task:", err)
		return
	}

	// 启动任务调度器
	c.start()

	// 等待一段时间后停止
	time.sleep(20 * time.second)
	c.stop()

	// 删除任务
	err = c.delbyid("task1")
	if err != nil {
		fmt.println("error deleting task:", err)
	}
}