golang cron 定时任务

 1package main
 2
 3import (
 4    "log"
 5
 6    "github.com/robfig/cron"
 7)
 8
 9func main() {
10    log.Println("Starting...")
11
12    c := cron.New()  // 新建一个定时任务对象
13    c.AddFunc("* * * * * *", func() {
14        log.Println("hello world")
15    })  // 给对象增加定时任务
16    c.Start()
17    select {
18    }
19}

 1 ┌─────────────second 范围 (0 - 60)
 2 │ ┌───────────── min (0 - 59)
 3 │ │ ┌────────────── hour (0 - 23)
 4 │ │ │ ┌─────────────── day of month (1 - 31)
 5 │ │ │ │ ┌──────────────── month (1 - 12)
 6 │ │ │ │ │ ┌───────────────── day of week (0 - 6) (0 to 6 are Sunday to
 7 │ │ │ │ │ │                  Saturday)
 8 │ │ │ │ │ │
 9 │ │ │ │ │ │
10 * * * * * *

1c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty") })

1type Cron struct {
2    entries  []*Entry
3    stop     chan struct{}   // 控制 Cron 实例暂停
4    add      chan *Entry     // 当 Cron 已经运行了，增加新的 Entity 是通过 add 这个 channel 实现的
5    snapshot chan []*Entry   // 获取当前所有 entity 的快照
6    running  bool            // 当已经运行时为true；否则为false
7}

 1type Entry struct {
 2    // The schedule on which this job should be run.
 3    // 负责调度当前 Entity 中的 Job 执行
 4    Schedule Schedule
 5
 6    // The next time the job will run. This is the zero time if Cron has not been
 7    // started or this entry's schedule is unsatisfiable
 8    // Job 下一次执行的时间
 9    Next time.Time
10
11    // The last time this job was run. This is the zero time if the job has never
12    // been run.
13    // 上一次执行时间
14    Prev time.Time
15
16    // The Job to run.
17    // 要执行的 Job
18    Job Job
19}

1type Job interface {
2    Run()
3}

1type Schedule interface {
2    // Return the next activation time, later than the given time.
3    // Next is invoked initially, and then each time the job is run.
4    // 返回同一 Entity 中的 Job 下一次执行的时间
5    Next(time.Time) time.Time
6}

1type SpecSchedule struct {
2    Second, Minute, Hour, Dom, Month, Dow uint64
3}

1type ConstantDelaySchedule struct {
2    Delay time.Duration // 循环的时间间隔
3}

1constDelaySchedule := Every(5e9)

1func New() *Cron {
2    return &Cron{
3        entries:  nil,
4        add:      make(chan *Entry),
5        stop:     make(chan struct{}),
6        snapshot: make(chan []*Entry),
7        running:  false,
8    }
9}

1func Parse(spec string) (_ Schedule, err error)

 1// 将 job 加入 Cron 中
 2// 如上所述，该方法只是简单的通过 FuncJob 类型强制转换 cmd，然后调用 AddJob 方法
 3func (c *Cron) AddFunc(spec string, cmd func()) error
 4
 5// 将 job 加入 Cron 中
 6// 通过 Parse 函数解析 cron 表达式 spec 的到调度器实例(Schedule)，之后调用 c.Schedule 方法
 7func (c *Cron) AddJob(spec string, cmd Job) error
 8
 9// 获取当前 Cron 总所有 Entities 的快照
10func (c *Cron) Entries() []*Entry
11
12// 通过两个参数实例化一个 Entity，然后加入当前 Cron 中
13// 注意：如果当前 Cron 未运行，则直接将该 entity 加入 Cron 中；
14// 否则，通过 add 这个成员 channel 将 entity 加入正在运行的 Cron 中
15func (c *Cron) Schedule(schedule Schedule, cmd Job)
16
17// 新启动一个 goroutine 运行当前 Cron
18func (c *Cron) Start()
19
20// 通过给 stop 成员发送一个 struct{}{} 来停止当前 Cron，同时将 running 置为 false
21// 从这里知道，stop 只是通知 Cron 停止，因此往 channel 发一个值即可，而不关心值是多少
22// 所以，成员 stop 定义为空 struct
23func (c *Cron) Stop()
24

 1package main
 2
 3import (
 4    "log"
 5
 6    "github.com/robfig/cron"
 7)
 8
 9type Hello struct {
10    Str string
11}
12
13func(h Hello) Run() {
14    log.Println(h.Str)
15}
16
17func main() {
18    log.Println("Starting...")
19
20    c := cron.New()
21    h := Hello{"I Love You!"}
22    // 添加定时任务
23    c.AddJob("*/2 * * * * * ", h)
24    // 添加定时任务
25    c.AddFunc("*/5 * * * * * ", func() {
26        log.Println("hello word")
27    })
28
29    s, err := cron.Parse("*/3 * * * * *")
30    if err != nil {
31        log.Println("Parse error")
32    }
33    h2 := Hello{"I Hate You!"}
34    c.Schedule(s, h2)
35    // 其中任务
36    c.Start()
37    // 关闭任务
38    defer c.Stop()
39    select {
40    }
41}