背景说明

最近工作上有个开发定时任务的需求，调研一下后发现Golang并没有十分完善的定时任务库。
整理我这边的需求如下：

• 支持启动仅定时执行一次的任务；
  
• 任务在执行之前可以完成撤销；
  
• 服务重启之后，未完成的定时任务需要允许重新调度；
  

显然，现成的cron库无法满足我的需求。限定于工期，最终自己实现了一个粗糙的事件驱动定时器。

但这个事件驱动定时器具有以下的缺点：

• 事件订阅/通知机制不成熟
  
• 无法适用于更灵活的场景，例如多节点的分布式任务调度执行
  
• 模块之间的职责不清晰，例如其实Timer模块是Scheduler调度器的一部分，Event定时器相关的部分也是Scheduler调度器的一部分，而Executor执行模块也存在任务调度的功能，实际上它只需要负责完成调度器交给它的任务就好
  
• 没有设计任务调度池，也就是但凡新建计划任务，就会在后台启动一个协程持续监听；一旦任务数量太多，后台停留的协程会越来越多，进程总的消耗就会变得非常夸张，非常可怕
  
• 任务调度时不存在优先级的概念，假如相同时间内有多个任务同时执行，哪个任务被优先调度完全取决于GMP的系统调度
  

综上，我需要着重考察现有的Golang任务调度框架，对任务定时器进行重新设计。

GoCron任务调度库

1. <a href="https://github.com/jasonlvhit/gocron" rel="external nofollow"  target="_blank">https://github.com/jasonlvhit/gocron</a>

复制代码

调用实例

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. 
   
7.         "github.com/jasonlvhit/gocron"
   
8. )
   
9. 
   
10. func task() {
    
11.         fmt.Println("I am running task.")
    
12. }
    
13. 
    
14. func taskWithParams(a int, b string) {
    
15.         fmt.Println(a, b)
    
16. }
    
17. 
    
18. func main() {
    
19.         // Do jobs without params
    
20.         gocron.Every(1).Second().Do(task)
    
21.         gocron.Every(2).Seconds().Do(task)
    
22.         gocron.Every(1).Minute().Do(task)
    
23.         gocron.Every(2).Minutes().Do(task)
    
24.         gocron.Every(1).Hour().Do(task)
    
25.         gocron.Every(2).Hours().Do(task)
    
26.         gocron.Every(1).Day().Do(task)
    
27.         gocron.Every(2).Days().Do(task)
    
28.         gocron.Every(1).Week().Do(task)
    
29.         gocron.Every(2).Weeks().Do(task)
    
30. 
    
31.         // Do jobs with params
    
32.         gocron.Every(1).Second().Do(taskWithParams, 1, "hello")
    
33. 
    
34.         // Do jobs on specific weekday
    
35.         gocron.Every(1).Monday().Do(task)
    
36.         gocron.Every(1).Thursday().Do(task)
    
37. 
    
38.         // Do a job at a specific time - 'hour:min:sec' - seconds optional
    
39.         gocron.Every(1).Day().At("10:30").Do(task)
    
40.         gocron.Every(1).Monday().At("18:30").Do(task)
    
41.         gocron.Every(1).Tuesday().At("18:30:59").Do(task)
    
42. 
    
43.         // Begin job immediately upon start
    
44.         gocron.Every(1).Hour().From(gocron.NextTick()).Do(task)
    
45. 
    
46.         // Begin job at a specific date/time
    
47.         t := time.Date(2019, time.November, 10, 15, 0, 0, 0, time.Local)
    
48.         gocron.Every(1).Hour().From(&t).Do(task)
    
49. 
    
50.         // NextRun gets the next running time
    
51.         _, time := gocron.NextRun()
    
52.         fmt.Println(time)
    
53. 
    
54.         // Remove a specific job
    
55.         gocron.Remove(task)
    
56. 
    
57.         // Clear all scheduled jobs
    
58.         gocron.Clear()
    
59. 
    
60.         // Start all the pending jobs
    
61.         <- gocron.Start()
    
62. 
    
63.         // also, you can create a new scheduler
    
64.         // to run two schedulers concurrently
    
65.         s := gocron.NewScheduler()
    
66.         s.Every(3).Seconds().Do(task)
    
67.         <- s.Start()
    
68. }

复制代码

项目分析

这个工具库仅有三个文件:

代码主要分为job和scheduler两个文件，gocron仅放置了回调方法和公共方法。项目整体架构如下：

gocron通过scheduler维护一个job列表，指定MAXJOBNUM最大工作队列，限制可执行的工作数大小。

1. // gocron/scheduler.go
   
2. // Scheduler struct, the only data member is the list of jobs.
   
3. // - implements the sort.Interface{} for sorting jobs, by the time nextRun
   
4. type Scheduler struct {
   
5.         jobs [MAXJOBNUM]*Job // Array store jobs
   
6.         size int             // Size of jobs which jobs holding.
   
7.         loc  *time.Location  // Location to use when scheduling jobs with specified times
   
8. }

复制代码

这里需要更正一下，并不是全局列表，仅仅只是跟随调度器的生命周期。实际上，代码确实存在全局的默认调度器：

1. var (
   
2.         defaultScheduler = NewScheduler()
   
3. )

复制代码

因此，可以直接调用。当然也支持实例化自己的调度器：

1. s := gocron.NewScheduler()
   
2. s.Every(3).Seconds().Do(task)
   
3. <- s.Start()

复制代码

gocron是典型的链式调用，scheduler对象通过返回job对象，完成job对象的封装操作之后，加入调度器内部的jobs列表，再通过Start方法启动调度器监控协程，轮询列表中的jobs，一旦找到可执行的任务，就会启动协程运行job的Func对象。

1. // Job struct keeping information about job
   
2. type Job struct {
   
3.         interval uint64                   // pause interval * unit between runs
   
4.         jobFunc  string                   // the job jobFunc to run, func[jobFunc]
   
5.         //......
   
6.         funcs    map[string]interface{}   // Map for the function task store
   
7.         fparams  map[string][]interface{} // Map for function and  params of function
   
8.         //......
   
9. }

复制代码

funcs维护一个map，缓存funcName到func的映射关系。具体封装在Do方法：

1. // gocron/job.go
   
2. // func (j *Job) Do(jobFun interface{}, params ...interface{}) error
   
3. fname := getFunctionName(jobFun)
   
4. j.funcs[fname] = jobFun
   
5. j.fparams[fname] = params
   
6. j.jobFunc = fname

复制代码

在执行任务时，通过反射回调func：

1. // gocron/job.go
   
2. // func (j *Job) run() ([]reflect.Value, error)
   
3. result, err := callJobFuncWithParams(j.funcs[j.jobFunc], j.fparams[j.jobFunc])
   
4. if err != nil {
   
5.         return nil, err
   
6. }
   
7. 
   
8. // gocron/gocron.go
   
9. func callJobFuncWithParams(jobFunc interface{}, params []interface{}) ([]reflect.Value, error) {
   
10.         f := reflect.ValueOf(jobFunc)
    
11.         if len(params) != f.Type().NumIn() {
    
12.                 return nil, ErrParamsNotAdapted
    
13.         }
    
14.         in := make([]reflect.Value, len(params))
    
15.         for k, param := range params {
    
16.                 in[k] = reflect.ValueOf(param)
    
17.         }
    
18.         return f.Call(in), nil
    
19. }

复制代码

启动调度器时，启动监控协程：

1. // Start all the pending jobs
   
2. // Add seconds ticker
   
3. func (s *Scheduler) Start() chan bool {
   
4.         stopped := make(chan bool, 1)
   
5.         // ticker每秒产生一个信号
   
6.         ticker := time.NewTicker(1 * time.Second)
   
7. 
   
8.         go func() {
   
9.                 for {
   
10.                         // select选择器阻塞
    
11.                         // case接收到信号则执行
    
12.                         // 同时接收到多个信号则随机选择一个执行
    
13.                         select {
    
14.                         // ticker每秒产生一次信号
    
15.                         // RunPending轮询jobs列表，寻找到了时间可执行的任务
    
16.                         case <-ticker.C:
    
17.                                 s.RunPending()
    
18.                         // stopped接收到停止信号，退出调度器协程
    
19.                         case <-stopped:
    
20.                                 ticker.Stop()
    
21.                                 return
    
22.                         }
    
23.                 }
    
24.         }()
    
25. 
    
26.         return stopped
    
27. }

复制代码

一个调度器一个协程，通过统一的调度协程去监控调度器任务列表内的任务。

1. // RunPending runs all the jobs that are scheduled to run.
   
2. func (s *Scheduler) RunPending() {
   
3.         // 轮询jobs列表，找到到时间可执行的任务，创建可执行任务列表
   
4.         runnableJobs, n := s.getRunnableJobs()
   
5. 
   
6.         if n != 0 {
   
7.                 for i := 0; i < n; i++ {
   
8.                         // 启动协程运行
   
9.                         go runnableJobs[i].run()
   
10.                         // 刷新job执行信息，等待下一轮调度
    
11.                         runnableJobs[i].lastRun = time.Now()
    
12.                         runnableJobs[i].scheduleNextRun()
    
13.                 }
    
14.         }
    
15. }

复制代码

综合分析

综上，gocron有如下好处：

• 链式调用简单易用
  
• scheduler和job职责清晰，项目架构非常容易理解
  
• 调度器一键启动协程监控，只有到了时间可执行的任务才会被加入到runablejobs列表，大大减少了进程中协程的数量，减少资源消耗
  
• 调度器维护的待执行任务池，存在预设的容量大小，限定了同时可执行的最大任务数量，不会导致超量
  

但它的缺陷也同样明显：

• 当不同的线程同时对同一个调度器进行操作，对任务列表产生的影响是不可预知的。因此这个框架下，最好是每个client维护自己的scheduler对象
  
• 虽然调度器维护一个jobs列表，但如果超过列表设定容量的任务便无法等待执行了……这一点gocron并没有理睬
  
• 几乎每秒，为了找到可执行的任务去构建runablejobs列表，都会轮询一次任务列表。为了追求结果的一致，它会对jobs进行排序，虽然Golang编译器对内置的sort方法进行了优化，会选举最快的方式对数据进行处理，但依然存在消耗
  
• 依然是内存操作，服务重启任务列表就不存在了。也没有考虑到多节点的场景。
  

新的GoCron分析

1. https://github.com/go-co-op/gocron原gocron的作者居然住进ICU了，管理员说截止至2020年3月依然无法联系上他。愿他身体安康……gocron被fork后有了新的发展，赶紧扒下来学习一下

复制代码

新的gocron新增了很多内容，依然围绕着Scheduler和Job进行链式操作，但新增了executor模块。executor仅负责执行Scheduler调度过来的任务。

项目架构

下面是项目README文档里公开的架构图：

新功能

新版gocron支持了cron格式的语法

1. // cron expressions supported
   
2. s.Cron("*/1 * * * *").Do(task) // every minute

复制代码

新增了异步和阻塞模式的两种调度方式

1. // you can start running the scheduler in two different ways:
   
2. // starts the scheduler asynchronously
   
3. s.StartAsync()
   
4. // starts the scheduler and blocks current execution path
   
5. s.StartBlocking()

复制代码

通过设置信号量限制可同时运行的任务数量

1. // gocron/scheduler.go
   
2. // SetMaxConcurrentJobs limits how many jobs can be running at the same time.
   
3. // This is useful when running resource intensive jobs and a precise start time is not critical.
   
4. func (s *Scheduler) SetMaxConcurrentJobs(n int, mode limitMode) {
   
5.         // 通过对n的配置修改并发任务数的大小
   
6.         s.executor.maxRunningJobs = semaphore.NewWeighted(int64(n))
   
7.         // limitMode即当可执行任务达到最大并发量时，应该如何处理的逻辑
   
8.         // RescheduleMode：跳过本次执行，等待下一次调度
   
9.         // WaitMode：持续等待，知道可执行队列空出。但，由于等待的任务数积累，可能导致不可预知的后果，某些任务可能一直等不到执行
   
10.         s.executor.limitMode = mode
    
11. }
    
12. 
    
13. // gocron/executor.go
    
14. // 通过信号量的方式从最大数量中取一位
    
15. // 若通过，下一步可以执行函数
    
16. if e.maxRunningJobs != nil {
    
17.         if !e.maxRunningJobs.TryAcquire(1) {
    
18. 
    
19.                 switch e.limitMode {
    
20.                 case RescheduleMode:
    
21.                         return
    
22.                 case WaitMode:
    
23.                         select {
    
24.                         case <-stopCtx.Done():
    
25.                                 return
    
26.                         case <-f.ctx.Done():
    
27.                                 return
    
28.                         default:
    
29.                         }
    
30. 
    
31.                         if err := e.maxRunningJobs.Acquire(f.ctx, 1); err != nil {
    
32.                                 break
    
33. 
    
34.                         }
    
35.                 }
    
36.         }
    
37. 
    
38.         defer e.maxRunningJobs.Release(1)
    
39. }

复制代码

gocron支持指定Job以单例模式运行。通过siglefilght工具库保证当前仅有一个可运行的Job

1. // gocron/job.go
   
2. // SingletonMode prevents a new job from starting if the prior job has not yet
   
3. // completed it's run
   
4. // Note: If a job is added to a running scheduler and this method is then used
   
5. // you may see the job run overrun itself as job is scheduled immediately
   
6. // by default upon being added to the scheduler. It is recommended to use the
   
7. // SingletonMode() func on the scheduler chain when scheduling the job.
   
8. func (j *Job) SingletonMode() {
   
9.         j.mu.Lock()
   
10.         defer j.mu.Unlock()
    
11.         j.runConfig.mode = singletonMode
    
12.         j.jobFunction.limiter = &singleflight.Group{}
    
13. }
    
14. 
    
15. // gocron/executor.go
    
16. switch f.runConfig.mode {
    
17. case defaultMode:
    
18.         runJob()
    
19. case singletonMode:
    
20.         // limiter是singlefilght对象，Do方法内仅会执行一次，保证一次只运行一个任务
    
21.         _, _, _ = f.limiter.Do("main", func() (interface{}, error) {
    
22.                 select {
    
23.                 case <-stopCtx.Done():
    
24.                         return nil, nil
    
25.                 case <-f.ctx.Done():
    
26.                         return nil, nil
    
27.                 default:
    
28.                 }
    
29.                 runJob()
    
30.                 return nil, nil
    
31.         })
    
32. }

复制代码

gocron主要数据结构

主要分为schduler调度器，job任务，以及executor执行器对象

追踪一下调用链的工作流程：

• 初始化一个Scheduler；新版gocron似乎更鼓励用户使用自己的scheduler，而不是如同老版一样维护一个默认的全局调度器
  

1. func NewScheduler(loc *time.Location) *Scheduler {
   
2.         //        这时已经将executor同步初始化完毕
   
3.         // scheduler和executor是一对一的关系
   
4.         executor := newExecutor()
   
5. 
   
6.         return &Scheduler{
   
7.                 jobs:       make([]*Job, 0),
   
8.                 location:   loc,
   
9.                 running:    false,
   
10.                 time:       &trueTime{},
    
11.                 executor:   &executor,
    
12.                 tagsUnique: false,
    
13.                 timer:      afterFunc,
    
14.         }
    
15. }

复制代码

• Every方法初始化一个Job，如果scheduler已经启动，即任务列表中已经存在一个等待封装的Job，那么直接取出相应的Job
  

1. if s.updateJob || s.jobCreated {
   
2.         job = s.getCurrentJob()
   
3. }

复制代码

接下来确定Job的运行周期，并加入到任务列表

1. s.setJobs(append(s.Jobs(), job))

复制代码

Every方法返回了新增Job的scheduler，此时scheduler的任务队列中存在一个Job就绪，等待下一步调度。

• Do方法带着回调的函数和对应的参数开始执行，它从当前的scheduler中取出一个就绪的Job，进行最后的判断，如果Job不合格，那么将它从任务队列中移除，并返回报错
  

1. if job.error != nil {
   
2.         // delete the job from the scheduler as this job
   
3.         // cannot be executed
   
4.         s.RemoveByReference(job)
   
5.         return nil, job.error
   
6. }
   
7. // 还有很多判断条件，这里不一一列举

复制代码

将Do方法将要执行的函数封装进Job。接下来判断schduler是否启动：如之前gocron一样，scheduler也是通过协程监听并执行启动任务协程的工作。
之前的scheduler，默认启动一个ticker，每秒去排序并轮询任务队列，从中取出满足条件的任务开始执行，效率非常低。而现在的改进是：scheduler启动监听协程后；不是以轮询而是以通知的方式，从channel中获取Job的Function，再启动协程去执行。
在这样的前提下，scheduler监听协程什么时候启动是位置的。此处添加一个判断，当scheduler启动时，同时启动runContinuous去完成Job的最后一步操作。若是scheduler没有启动，那么直接返回，等待scheduler启动后再完成操作。

1. // we should not schedule if not running since we can't foresee how long it will take for the scheduler to start
   
2. if s.IsRunning() {
   
3.         s.runContinuous(job)
   
4. }

复制代码

通过这样的设计，在最终启动scheduler前后，都可以以动态的方式添加/移除任务。

• scheduler提供了两种启动schduler的模式：异步和阻塞（也就是同步啦）
  

1. // StartAsync starts all jobs without blocking the current thread
   
2. func (s *Scheduler) StartAsync() {
   
3.         if !s.IsRunning() {
   
4.                 s.start()
   
5.         }
   
6. }
   
7. 
   
8. // StartBlocking starts all jobs and blocks the current thread.
   
9. // This blocking method can be stopped with Stop() from a separate goroutine.
   
10. func (s *Scheduler) StartBlocking() {
    
11.         s.StartAsync()
    
12.         s.startBlockingStopChanMutex.Lock()
    
13.         s.startBlockingStopChan = make(chan struct{}, 1)
    
14.         s.startBlockingStopChanMutex.Unlock()
    
15.         <-s.startBlockingStopChan
    
16. }

复制代码

一般情况下，我们通过异步模式，启动对所有任务的监控

1. // start starts the scheduler, scheduling and running jobs
   
2. func (s *Scheduler) start() {
   
3.         // 启动监听协程，select选择器配合channel阻塞
   
4.         // 直到Job准备执行发送通知
   
5.         go s.executor.start()
   
6.         // 将scheduler置位为running
   
7.         s.setRunning(true)
   
8.         // 遍历所有任务，以递归的方式监控起来
   
9.         s.runJobs(s.Jobs())
   
10. }

复制代码

比较有意思的是这个部分：

1. func (s *Scheduler) runJobs(jobs []*Job) {
   
2.         for _, job := range jobs {
   
3.                 // 这个函数是一个递归调用
   
4.                 // 这里对所有Job都以递归的方式监听着
   
5.                 s.runContinuous(job)
   
6.         }
   
7. }
   
8. 
   
9. // 这是runContinuous的部分代码
   
10. job.setTimer(s.timer(nextRun, func() {
    
11.         if !next.dateTime.IsZero() {
    
12.                 for {
    
13.                         n := s.now().UnixNano() - next.dateTime.UnixNano()
    
14.                         // 某个任务满足执行条件了，退出循环
    
15.                         if n >= 0 {
    
16.                                 break
    
17.                         }
    
18.                         s.time.Sleep(time.Duration(n))
    
19.                 }
    
20.         }
    
21.         // 递归执行本方法
    
22.         // runContinuous会判断当前Job是否可执行
    
23.         // 若不则退出，若可以则将Job设置为立即执行，并刷新执行时间
    
24.         // 若Job“立即执行”的标志已经置位，直接调用run发送通知给监听协程
    
25.         s.runContinuous(job)
    
26. }))

复制代码

这样的设计太优雅了，大佬们的奇思妙想啊～

• 最后是executor的执行，前面已经提到过。通过select接收channel通知的形式执行下去，核心方法是这个：
  

1. runJob := func() {
   
2.         f.incrementRunState()
   
3.         callJobFunc(f.eventListeners.onBeforeJobExecution)
   
4.         callJobFuncWithParams(f.function, f.parameters)
   
5.         callJobFunc(f.eventListeners.onAfterJobExecution)
   
6.         f.decrementRunState()
   
7. }

复制代码

eventListeners封装了两个接口，用以在执行任务和完成任务后发送给用户事件通知。
综合分析

gocron进行了不少方面的优化：

• 在任务列表的维护上，可加入调度的任务数不再限定为某个值，而是以切片的方式自动增长。但最终能够并行执行的任务数却通过信号量多方式加以控制；
  
• 不再周期性地轮询任务列表，以期待获得可运行的任务；而是通过更巧妙的方式，任务递归监听，一旦发现可执行的任务，就自行通知scheduler，完成调度；
  
• 具备更丰富的语法和模式，用户可以根据场景自行选择；调度器同时支持异步及同步调用，而Job也支持周期性轮询和单点任务；
  
• scheduler内加锁了，对Jobs列表的操作都会加上读写锁，一些其它的参数也拥有自己的锁。这使得scheduler具备线程安全性，但某种程度上影响了对Jobs队列的操作。考虑到gocron不再鼓励使用全局Scheduler，而是每个client维护自己的Scheduler，那么被锁影响的场景会进一步减少，与最终优化获得的性能提升相比，都是值得的。
  

最后

最后的最后，gocron依然无法满足我当前的需求，但已经不妨碍我对源码进行下一步的改造：

• 我需要对Job进行上层的封装，并将要调用的方法和参数序列化后存入数据库，直到服务重启时，能够找到未完成的任务加载进scheduler重新执行
  
• 我的计划任务只需要执行一次，而无须重复执行，这一点已经有SingletonMode保证
  
• 我需要改造gocron，让它能够支持在某个时间范围内调度任务
  

到此这篇关于Golang定时任务框架GoCron的源码分析的文章就介绍到这了,更多相关Golang定时任务框架GoCron内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！