Go框架进阶—定时任务 goCron

goCron是一个Golang作业调度工具，可以使用简单的语法定期执行go函数。

github：GitHub - jasonlvhit/gocron: A Golang Job Scheduling Package.

api doc：https://godoc.org/github.com/jasonlvhit/gocron#Every

使用实例

package main

import (
"fmt"
"github.com/jasonlvhit/gocron"
)

func task() {
	fmt.Println("I am runnning task.")
}

func taskWithParams(a int, b string) {
	fmt.Println(a, b)
}

func main() {
	//可并发运行多个任务
	//注意 interval>1时调用sAPi
	gocron.Every(2).Seconds().Do(task)
	gocron.Every(1).Second().Do(taskWithParams, 1, "hi")
	//在cron所有操作最后调用 start函数，否则start之后调用的操作无效不执行
	//<-gocron.Start()

	//在task执行过程中 禁止异常退出
	gocron.Every(1).Minute().DoSafely(taskWithParams, 1, "hello")

	// 支持在具体某一天、某天的某一时刻、每y-M-d h-m-s 执行任务
	gocron.Every(1).Monday().Do(task)
	gocron.Every(1).Thursday().Do(task)
	// function At() take a string like 'hour:min'
	gocron.Every(1).Day().At("10:30").Do(task)
	gocron.Every(1).Monday().At("18:30").Do(task)

	// 删除某一任务
	gocron.Remove(task)

	//删除所有任务
	gocron.Clear()

	//可同时创建一个新的任务调度 2个schedulers 同时执行
	s := gocron.NewScheduler()
	s.Every(3).Seconds().Do(task)
	<-s.Start()

	//防止多个集群中任务同时执行 task 实现lock接口
	//两行代码，对cron 设置lock实现，执行task时调用Lock方法再Do task
	gocron.SetLocker(lockerImplementation)
	gocron.Every(1).Hour().Lock().Do(task)

	<-gocron.Start()
}

源码浅析

 轻量 简洁的链式调用，看工程源码，简洁的……只有一个类。gocron当前支持最多1w个任务数，核心对象就是维护了job对象，所有执行的任务都放在jobs数组中，start方法底层调用go time包下的NewTicker，新启一个线程执行task方法。

外部调用的gocron.start func调用链

// Start all the pending jobs
// Add seconds ticker
func (s *Scheduler) Start() chan bool {
	stopped := make(chan bool, 1)
	ticker := time.NewTicker(1 * time.Second)

	go func() {
		for {
			select {
			case <-ticker.C:
				s.RunPending()    //调用RunPending 执行数组有序的任务队列
			case <-stopped:
				ticker.Stop()
				return
			}
		}
	}()

	return stopped
}

// RunPending runs all the jobs that are scheduled to run.
func (s *Scheduler) RunPending() {
	runnableJobs, n := s.getRunnableJobs()

	if n != 0 {
		for i := 0; i < n; i++ {
			runnableJobs[i].run()
		}
	}
}

//run方法，反射获取job的各属性，最终调用function.call方法执行任务函数
//Run the job and immediately reschedule it
func (j *Job) run() (result []reflect.Value, err error) {
	if j.lock {
		if locker == nil {
			err = fmt.Errorf("trying to lock %s with nil locker", j.jobFunc)
			return
		}
		key := getFunctionKey(j.jobFunc)

		if ok, err := locker.Lock(key); err != nil || !ok {
			return nil, err
		}

		defer func() {
			if e := locker.Unlock(key); e != nil {
				err = e
			}
		}()
	}

	f := reflect.ValueOf(j.funcs[j.jobFunc])
	params := j.fparams[j.jobFunc]
	if len(params) != f.Type().NumIn() {
		err = errors.New("the number of param is not adapted")
		return
	}
	in := make([]reflect.Value, len(params))
	for k, param := range params {
		in[k] = reflect.ValueOf(param)
	}
	result = f.Call(in)
	j.lastRun = time.Now()
	j.scheduleNextRun()
	return
}

这里需要关注一下，gocron对lock的实现，从代码上看Job结构体的lock属性，用于控制多实例job并发执行。但项目woner提到的 multiple instances 指的并不是跨服务器的多实例，而是在同一应用服务 里的多任务实例（也就是1个app服务中多个任务，粒度是只在统一应用内）。如果跨server则lock需要自行依赖redis或其他分布式锁来管理。通过读源码的run方法，j.lock来控制job并发，但一旦跨server job.lock属性是没法共享的。这里doc上给的解释有点歧义，需要注意。

If you need to prevent a job from running at the same time from multiple cron instances (like running a cron app from multiple servers), you can provide a Locker implementation and lock the required jobs. 然后owner给出了一个基于redis来做的lock 

Job结构体

// Job struct keeping information about job
type Job struct {
	interval uint64                   // pause interval * unit bettween runs
	jobFunc  string                   // the job jobFunc to run, func[jobFunc]
	unit     string                   // time units, ,e.g. 'minutes', 'hours'...
	atTime   time.Duration            // optional time at which this job runs
	lastRun  time.Time                // datetime of last run
	nextRun  time.Time                // datetime of next run
	startDay time.Weekday             // Specific day of the week to start on
	funcs    map[string]interface{}   // Map for the function task store
	fparams  map[string][]interface{} // Map for function and  params of function
	lock     bool                     // lock the job from running at same time form multiple instances
}

scheduler内维护JOBs array数组和大小，gocron scheduler最大可执行1w个job（大小可重写）。

// Scheduler struct, the only data member is the list of jobs.
// - implements the sort.Interface{} for sorting jobs, by the time nextRun
type Scheduler struct {
	jobs [MAXJOBNUM]*Job // Array store jobs ，const MAXJOBNUM = 10000
	size int             // Size of jobs which jobs holding.
}

对于执行时间的控制，均通过对job的unit属性进行设置，代码如下

// Seconds set the unit with seconds
func (j *Job) Seconds() *Job {
	return j.setUnit("seconds")
}

// Minutes set the unit with minute
func (j *Job) Minutes() *Job {
	return j.setUnit("minutes")
}

// Second set the unit with second
func (j *Job) Second() *Job {
	j.mustInterval(1)
	return j.Seconds()
}

// Minute set the unit  with minute, which interval is 1
func (j *Job) Minute() *Job {
	j.mustInterval(1)
	return j.Minutes()
}

// Sunday sets the job start day Sunday
func (j *Job) Sunday() *Job {
	return j.Weekday(time.Sunday)
}

// Every schedule a new periodic job with interval
func (s *Scheduler) Every(interval uint64) *Job {
	job := NewJob(interval)
	s.jobs[s.size] = job
	s.size++
	return job
}

简单总结

gocron代码总共570行，在java中但凡涉及到一点“通用工具”或“架构”的实现，除了多依赖之外，撸代码是少不了的。但在go中要实现满足基本功能的cron任务调度，没有多余依赖，纯基于gosdk本身，575行代码打完收工。这是在不接触go语言之前设想不到的事情。轻量好用，为中间件而生。

编程语言跟人类沟通语言一样，属性都是工具，透过这个工具无论作为人或是工程师，给我们打开的是另一个世界和景象。在对比中扬长避短，可对比的资源越多，越是能找到最优方案。不怕不知道，就怕不知道。