定时任务调度是常见的场景，从简单点本地任务调度，到分布式定时任务调度，被广泛的使用。本文汇总了 awesome-go 里全部的本地定时任务库，并横向对比其实现原理，以及使用场景和优缺点，欢迎收藏随时参考。

本文收纳的本地定时任务库如下：

1. onatm/clockwerk
2. withself/clockwork
3. kr/go-cron
4. roylee0704/gron
5. carlescere/scheduler

1. 定时任务基础

最基础的定时任务

众所周知，go 语言的 time 库提供了 Ticker 方法，可以通过：

ticker := time.NewTicker(duration) 的方式获取到一个定时返回的 chan，此可以用来帮助我们实现基础的定时任务功能，比如如下函数就是基础的实现：

package main

import (
    "fmt"
    "time"
)

func NewCronJob(duration time.Duration, job func()) (stopChan chan bool) {
    ticker := time.NewTicker(duration)
    stopChan = make(chan bool)

    go func(ticker *time.Ticker) {
        defer ticker.Stop()
        // 由于ticker.Stop()内部不会关闭chan，故使用 for range 会内存泄露
        // 推荐使用 for + select + return 的方式，让 ticker 最终被GC
        for {
            select {
            case <-ticker.C:
                job()
            case stop := <-stopChan:
                if stop {
                    close(stopChan)
                    return
                }
            }
        }
    }(ticker)

    return stopChan
}

func main() {
    stopCtr := NewCronJob(2*time.Second, func() {
        fmt.Printf("hello word:%+v\n", time.Now())
    })

    time.Sleep(10 * time.Second)

    stopCtr <- true

    // example output:
    // hello word:2023-02-26 11:10:17.470147 +0800 CST m=+2.001352251
    // hello word:2023-02-26 11:10:19.470141 +0800 CST m=+4.001330084
    // hello word:2023-02-26 11:10:21.470154 +0800 CST m=+6.001327917
    // hello word:2023-02-26 11:10:23.469824 +0800 CST m=+8.000981501
    // hello word:2023-02-26 11:10:25.470273 +0800 CST m=+10.001414209
}

使用 time.Sleep() 也可以实现这个功能，但是 Ticker 会更加优雅些。

cron 表达式

time.Ticker() 非常简单好用，但是也有不足，就是难以控制让任务在准确地时间里执行，比如 ticker 可以实现每半个小时执行一次，但是无法直接实现，每个小时 30 分时执行一次。

Linux 系统里的 crontab 可以完美解决这个问题，通过类似如下的字符串，就定义了在每个小时 30 分执行的任务。

30 * * * *

corntab 只有五位

*    *    *    *    *
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- 星期几 (0 - 6) (星期天=0)
|    |    |    +---------- 月份 (1 - 12) 
|    |    +--------------- 一个月中的第几天 (1 - 31)
|    +-------------------- 小时 (0 - 23)
+------------------------- 分钟 (0 - 59)

基础 corntab 派生的 corn 有 6 位或者 7 位，多出的一到两位，精确到了秒或者年，具体可参考此文。

像开源的 robfig/cron 就是 Go 的知名开源corn库。

2. 定时任务通用实现——基础

如果将上述定时任务的实例代码进行封装，就可以实现一个简单由实用的定时任务。下文将分析并对比，awesome-go 推荐的定时任务库。

经典样例——onatm/clockwerk

先看下使用样例：

type DummyJob struct{}

func (d DummyJob) Run() {
  fmt.Println("Every 30 seconds")
}

func main() {
  var job DummyJob
  c := clockwerk.New()
  c.Every(30 * time.Second).Do(job)
  c.Start()
}

1. New 创建一个调度对象
2. Every 确定的 duration
3. Do 将任务加入调度对象
4. Start 启动执行调度对象里的任务

源码非常简洁，直接上流程图：

其核心控制逻辑是：

func (c *Clockwerk) run() {
    ticker := time.NewTicker(100 * time.Millisecond)
    go func() {
        for {
            select {
            case <-ticker.C:
                // 遍历所有的job，执行到点的任务
                c.runPending()
                continue
            case <-c.stop:
                ticker.Stop()
                return
            }
        }
    }()
}

其他开源库对比

综合我们可以总结出来，核心流程：