# v1.2
go get github.com/robfig/cron
# v3
go get github.com/robfig/cron/v3@v3.0.0

package main
import (
?? ?"fmt"
?? ?"github.com/robfig/cron/v3"
?? ?"time"
)
func main() {
?? ?// 新建一個(gè)定時(shí)任務(wù)對(duì)象,根據(jù)cron表達(dá)式進(jìn)行時(shí)間調(diào)度,cron可以精確到秒,大部分表達(dá)式格式也是從秒開(kāi)始
?? ?// 默認(rèn)從分開(kāi)始進(jìn)行時(shí)間調(diào)度
?? ?// cronTab := cron.New()
?? ?// 精確到秒
?? ?cronTab := cron.New(cron.WithSeconds())
?? ?// 定義定時(shí)器調(diào)用的任務(wù)函數(shù)
?? ?task := func() {
?? ??? ?fmt.Println("hello world", time.Now())
?? ?}
?? ?// 定時(shí)任務(wù),cron表達(dá)式,每五秒一次
?? ?spec := "*/5 * * * * ?"
?? ?// 添加定時(shí)任務(wù)
?? ?cronTab.AddFunc(spec, task)
?? ?// 啟動(dòng)定時(shí)器
?? ?cronTab.Start()
?? ?// 阻塞主線程停止
?? ?select {}
}

@every <duration>

// 例如
c := cron.New() 
c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })

package main
import (
?? ?"fmt"
?? ?"github.com/robfig/cron/v3"
?? ?"time"
)
func main() {
?? ?//直接配置時(shí)區(qū)
?? ?nyc, _ := time.LoadLocation("America/New_York")
?? ?// cron.New(cron.WithLocation(time.UTC))
?? ?c := cron.New(cron.WithLocation(nyc),cron.WithSeconds())
?? ?c.AddFunc("*/5 * * * * ?", func() {
?? ??? ?fmt.Println("Every 5 second at New York")
?? ?})
?? ?// 參數(shù)里面配置時(shí)區(qū)
?? ?c.AddFunc("CRON_TZ=Asia/Tokyo */5 * * * * ?", func() {
?? ??? ?fmt.Println("Every 5 second at Tokyo")
?? ?})
?? ?c.Start()
?? ?select {}
}

package main
import (
?? ?"fmt"
?? ?"github.com/robfig/cron/v3"
?? ?"time"
)
type Task1 struct {
?? ?Name string
}
// 自定義定時(shí)任務(wù)只需要實(shí)現(xiàn)Job接口的Run方法
func (t *Task1) Run() {
?? ?fmt.Println("Task1: ", t.Name)
}
type Task2 struct {
?? ?Name string
}
// 自定義定時(shí)任務(wù)只需要實(shí)現(xiàn)Job接口的Run方法
func (t *Task2) Run() {
?? ?fmt.Println("Task2: ", t.Name)
}
func main() {
?? ?cronTab := cron.New(cron.WithSeconds())
?? ?// 定義定時(shí)器調(diào)用的任務(wù)函數(shù)
?? ?// 定時(shí)任務(wù)
?? ?// cron表達(dá)式,每五秒一次
?? ?spec := "*/5 * * * * ?"
?? ?//定義定時(shí)器調(diào)用的任務(wù)函數(shù)
?? ?task := func() {
?? ??? ?fmt.Println("hello world", time.Now())
?? ?}
?? ?// 添加多個(gè)定時(shí)器
?? ?cronTab.AddFunc(spec, task)
?? ?cronTab.AddJob(spec, &Task1{Name: "tom"})
?? ?cronTab.AddJob(spec, &Task2{Name: "merry"})
?? ?// 啟動(dòng)定時(shí)器
?? ?cronTab.Start()
?? ?// 關(guān)閉,但是不能關(guān)閉已經(jīng)在執(zhí)行中的任務(wù)
?? ?defer cronTab.Stop()
?? ?// 阻塞主線程停止
?? ?select {}
}

// Job is an interface for submitted cron jobs.
type Job interface {
    Run()
}

// 它通過(guò)簡(jiǎn)單的實(shí)現(xiàn)Run()方法來(lái)實(shí)現(xiàn)Job接口
type FuncJob func()
// 這樣,任何無(wú)參數(shù)無(wú)返回值的函數(shù),通過(guò)強(qiáng)制類(lèi)型轉(zhuǎn)換為FuncJob,就可以當(dāng)作Job來(lái)使用了,AddFunc方法就是這么做的
func (f FuncJob) Run() { f() }

// Schedule describes a job's duty cycle.
type Schedule interface {
    // Next returns the next activation time, later than the given time.
    // Next is invoked initially, and then each time the job is run.
    // 返回同一Entity中的Job下一次執(zhí)行的時(shí)間
    Next(time.Time) time.Time
}

// SpecSchedule specifies a duty cycle (to the second granularity), based on a
// traditional crontab specification. It is computed initially and stored as bit sets.
type SpecSchedule struct {
?? ?Second, Minute, Hour, Dom, Month, Dow uint64
?? ?// Override location for this schedule.
?? ?Location *time.Location
}

// ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes".
// It does not support jobs more frequent than once a second.
type ConstantDelaySchedule struct {
    // 循環(huán)的時(shí)間間隔
    Delay time.Duration
}

// Next returns the next time this should be run.
// This rounds so that the next activation time will be on the second.
func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
    return t.Add(schedule.Delay - time.Duration(t.Nanosecond())*time.Nanosecond)
}

package main
import (
?? ?"fmt"
?? ?"github.com/robfig/cron/v3"
)
func main() {
?? ?constDelaySchedule1 := cron.Every(5e9)
?? ?// 5s
?? ?fmt.Println(constDelaySchedule1.Delay)
?? ?constDelaySchedule2 := cron.Every(5e6)
?? ?// 1s
?? ?fmt.Println(constDelaySchedule2.Delay)
}

// Every returns a crontab Schedule that activates once every duration.
// Delays of less than a second are not supported (will round up to 1 second).
// Any fields less than a Second are truncated.
func Every(duration time.Duration) ConstantDelaySchedule {
    if duration < time.Second {
        duration = time.Second
    }
    return ConstantDelaySchedule{
        Delay: duration - time.Duration(duration.Nanoseconds())%time.Second,
    }
}

// Entry consists of a schedule and the func to execute on that schedule.
type Entry struct {
?? ?// ID is the cron-assigned ID of this entry, which may be used to look up a
?? ?// snapshot or remove it.
?? ?ID EntryID
?? ?// Schedule on which this job should be run.
? ?? ?// 負(fù)責(zé)調(diào)度當(dāng)前Entity中的Job執(zhí)行
?? ?Schedule Schedule
?? ?// Next time the job will run, or the zero time if Cron has not been
?? ?// started or this entry's schedule is unsatisfiable
? ?? ?// Job下一次執(zhí)行的時(shí)間
?? ?Next time.Time
?? ?// Prev is the last time this job was run, or the zero time if never.
? ?? ?// 上一次執(zhí)行時(shí)間
?? ?Prev time.Time
?? ?// WrappedJob is the thing to run when the Schedule is activated.
?? ?WrappedJob Job
?? ?// Job is the thing that was submitted to cron.
?? ?// It is kept around so that user code that needs to get at the job later,
?? ?// e.g. via Entries() can do so.
? ?? ?// 要執(zhí)行的Job
?? ?Job Job
}

// Cron keeps track of any number of entries, invoking the associated func as
// specified by the schedule. It may be started, stopped, and the entries may
// be inspected while running.
type Cron struct {
    entries   []*Entry
    chain     Chain
    stop      chan struct{} // 控制Cron實(shí)例暫停
    add       chan *Entry    // 當(dāng)Cron已經(jīng)運(yùn)行了,增加新的Entity是通過(guò)add這個(gè)channel實(shí)現(xiàn)的
    remove    chan EntryID
    snapshot  chan chan []Entry // 獲取當(dāng)前所有entity的快照
    running   bool // 當(dāng)已經(jīng)運(yùn)行時(shí)為true,否則為false
    logger    Logger
    runningMu sync.Mutex
    location  *time.Location
    parser    Parser
    nextID    EntryID
    jobWaiter sync.WaitGroup
}

// Remove an entry from being run in the future.
func (c *Cron) Remove(id EntryID) {
?? ?c.runningMu.Lock()
?? ?defer c.runningMu.Unlock()
?? ?if c.running {
?? ??? ?c.remove <- id
?? ?} else {
?? ??? ?c.removeEntry(id)
?? ?}
}
// Schedule adds a Job to the Cron to be run on the given schedule.
// The job is wrapped with the configured Chain.
func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID {
?? ?c.runningMu.Lock()
?? ?defer c.runningMu.Unlock()
?? ?c.nextID++
?? ?entry := &Entry{
?? ??? ?ID: ? ? ? ? c.nextID,
?? ??? ?Schedule: ? schedule,
?? ??? ?WrappedJob: c.chain.Then(cmd),
?? ??? ?Job: ? ? ? ?cmd,
?? ?}
?? ?if !c.running {
?? ??? ?c.entries = append(c.entries, entry)
?? ?} else {
?? ??? ?c.add <- entry
?? ?}
?? ?return entry.ID
}

// New returns a new Cron job runner, modified by the given options.
//
// Available Settings
//
// ? Time Zone
// ? ? Description: The time zone in which schedules are interpreted
// ? ? Default: ? ? time.Local
//
// ? Parser
// ? ? Description: Parser converts cron spec strings into cron.Schedules.
// ? ? Default: ? ? Accepts this spec: https://en.wikipedia.org/wiki/Cron
//
// ? Chain
// ? ? Description: Wrap submitted jobs to customize behavior.
// ? ? Default: ? ? A chain that recovers panics and logs them to stderr.
//
// See "cron.With*" to modify the default behavior.
// 實(shí)例化時(shí),成員使用的基本是默認(rèn)值
func New(opts ...Option) *Cron {
?? ?c := &Cron{
?? ??? ?entries: ? nil,
?? ??? ?chain: ? ? NewChain(),
?? ??? ?add: ? ? ? make(chan *Entry),
?? ??? ?stop: ? ? ?make(chan struct{}),
?? ??? ?snapshot: ?make(chan chan []Entry),
?? ??? ?remove: ? ?make(chan EntryID),
?? ??? ?running: ? false,
?? ??? ?runningMu: sync.Mutex{},
?? ??? ?logger: ? ?DefaultLogger,
?? ??? ?location: ?time.Local,
?? ??? ?parser: ? ?standardParser,
?? ?}
?? ?for _, opt := range opts {
?? ??? ?opt(c)
?? ?}
?? ?return c
}
// Start the cron scheduler in its own goroutine, or no-op if already started.
func (c *Cron) Start() {
?? ?c.runningMu.Lock()
?? ?defer c.runningMu.Unlock()
?? ?if c.running {
?? ??? ?return
?? ?}
?? ?c.running = true
?? ?go c.run()
}

// Run the cron scheduler, or no-op if already running.
func (c *Cron) Run() {
?? ?c.runningMu.Lock()
?? ?if c.running {
?? ??? ?c.runningMu.Unlock()
?? ??? ?return
?? ?}
?? ?c.running = true
?? ?c.runningMu.Unlock()
?? ?c.run()
}
// run the scheduler.. this is private just due to the need to synchronize
// access to the 'running' state variable.
func (c *Cron) run() {
?? ?c.logger.Info("start")
?? ?// Figure out the next activation times for each entry.
?? ?now := c.now()
?? ?for _, entry := range c.entries {
?? ??? ?entry.Next = entry.Schedule.Next(now)
?? ??? ?c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next)
?? ?}
?? ?for {
?? ??? ?// Determine the next entry to run.
?? ??? ?sort.Sort(byTime(c.entries))
?? ??? ?var timer *time.Timer
?? ??? ?if len(c.entries) == 0 || c.entries[0].Next.IsZero() {
?? ??? ??? ?// If there are no entries yet, just sleep - it still handles new entries
?? ??? ??? ?// and stop requests.
?? ??? ??? ?timer = time.NewTimer(100000 * time.Hour)
?? ??? ?} else {
?? ??? ??? ?timer = time.NewTimer(c.entries[0].Next.Sub(now))
?? ??? ?}
?? ??? ?for {
?? ??? ??? ?select {
?? ??? ??? ?case now = <-timer.C:
?? ??? ??? ??? ?now = now.In(c.location)
?? ??? ??? ??? ?c.logger.Info("wake", "now", now)
?? ??? ??? ??? ?// Run every entry whose next time was less than now
?? ??? ??? ??? ?for _, e := range c.entries {
?? ??? ??? ??? ??? ?if e.Next.After(now) || e.Next.IsZero() {
?? ??? ??? ??? ??? ??? ?break
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?c.startJob(e.WrappedJob)
?? ??? ??? ??? ??? ?e.Prev = e.Next
?? ??? ??? ??? ??? ?e.Next = e.Schedule.Next(now)
?? ??? ??? ??? ??? ?c.logger.Info("run", "now", now, "entry", e.ID, "next", e.Next)
?? ??? ??? ??? ?}
?? ??? ??? ?case newEntry := <-c.add:
?? ??? ??? ??? ?timer.Stop()
?? ??? ??? ??? ?now = c.now()
?? ??? ??? ??? ?newEntry.Next = newEntry.Schedule.Next(now)
?? ??? ??? ??? ?c.entries = append(c.entries, newEntry)
?? ??? ??? ??? ?c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next)
?? ??? ??? ?case replyChan := <-c.snapshot:
?? ??? ??? ??? ?replyChan <- c.entrySnapshot()
?? ??? ??? ??? ?continue
?? ??? ??? ?case <-c.stop:
?? ??? ??? ??? ?timer.Stop()
?? ??? ??? ??? ?c.logger.Info("stop")
?? ??? ??? ??? ?return
?? ??? ??? ?case id := <-c.remove:
?? ??? ??? ??? ?timer.Stop()
?? ??? ??? ??? ?now = c.now()
?? ??? ??? ??? ?c.removeEntry(id)
?? ??? ??? ??? ?c.logger.Info("removed", "entry", id)
?? ??? ??? ?}
?? ??? ??? ?break
?? ??? ?}
?? ?}
}
// startJob runs the given job in a new goroutine.
func (c *Cron) startJob(j Job) {
?? ?c.jobWaiter.Add(1)
?? ?go func() {
?? ??? ?defer c.jobWaiter.Done()
?? ??? ?j.Run()
?? ?}()
}

// EntryID標(biāo)識(shí)Cron實(shí)例中的entry
type EntryID int
// 將job加入Cron中
// 如上所述,該方法只是簡(jiǎn)單的通過(guò)FuncJob類(lèi)型強(qiáng)制轉(zhuǎn)換cmd,然后調(diào)用AddJob方法
func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error)?
// 將job加入Cron中
// 通過(guò)Parse函數(shù)解析cron表達(dá)式spec的到調(diào)度器實(shí)例(Schedule),之后調(diào)用c.Schedule方法
func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error)
// 獲取當(dāng)前Cron總所有Entities的快照
func (c *Cron) Entries() []*Entry
// Location獲取時(shí)區(qū)位置
func (c *Cron) Location() *time.Location?
// Entry返回給定項(xiàng)的快照,如果找不到則返回nil
func (c *Cron) Entry(id EntryID) Entry
// 刪除將來(lái)運(yùn)行的條目
func (c *Cron) Remove(id EntryID)?
// 通過(guò)兩個(gè)參數(shù)實(shí)例化一個(gè)Entity,然后加入當(dāng)前Cron中
// 注意: 如果當(dāng)前Cron未運(yùn)行,則直接將該entity加入Cron中
// 否則,通過(guò)add這個(gè)成員channel將entity加入正在運(yùn)行的Cron中
func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID
// 新啟動(dòng)一個(gè)goroutine運(yùn)行當(dāng)前Cron
func (c *Cron) Start()
// 通過(guò)給stop成員發(fā)送一個(gè)struct{}{}來(lái)停止當(dāng)前Cron,同時(shí)將running置為false
// 從這里知道,stop只是通知Cron停止,因此往channel發(fā)一個(gè)值即可,而不關(guān)心值是多少
// 所以,成員stop定義為空struct
func (c *Cron) Stop()
// 運(yùn)行cron調(diào)度程序,如果已經(jīng)在運(yùn)行,則不運(yùn)行op
func (c *Cron) Run()

package main
import (
?? ?"fmt"
?? ?"time"
)
func main(){
?? ?go func() {
?? ??? ?for true {
?? ??? ??? ?fmt.Println("Hello World!",time.Now())
?? ??? ??? ?time.Sleep(1 * time.Second)
?? ??? ?}
?? ?}()
?? ?select {
?? ?}
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?// 創(chuàng)建一個(gè)Timer實(shí)例,設(shè)置2秒后執(zhí)行任務(wù)
?? ?t := time.NewTimer(2 * time.Second)
?? ?// 記得釋放Timer資源
?? ?defer t.Stop()
?? ?// 等待Timer到期
?? ?<-t.C
?? ?// 執(zhí)行任務(wù)
?? ?fmt.Println("Task executed at", time.Now())
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?done := make(chan bool)
?? ?ticker := time.NewTimer(1 * time.Second)
?? ?go func() {
?? ??? ?for {
?? ??? ??? ?select {
?? ??? ??? ?case <-done:
?? ??? ??? ??? ?ticker.Stop()
?? ??? ??? ??? ?return
?? ??? ??? ?case <-ticker.C:
?? ??? ??? ??? ?fmt.Println("Hello World!")
?? ??? ??? ?}
?? ??? ?}
?? ?}()
?? ?time.Sleep(10 *time.Second)
?? ?done <- true
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?fmt.Println("hello world", time.Now())
?? ?// 創(chuàng)建一個(gè)定時(shí)器
?? ?// 設(shè)置7秒后執(zhí)行一次
?? ?myT := time.NewTimer(7 * time.Second)
?? ?// 重置定時(shí)器為1s后執(zhí)行
?? ?myT.Reset(1 * time.Second)
?? ?<-myT.C
?? ?fmt.Println("hello world", time.Now())
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?// 創(chuàng)建一個(gè)Ticker實(shí)例,每隔1秒執(zhí)行一次任務(wù)
?? ?ticker := time.NewTicker(1 * time.Second)
?? ?// 記得釋放Ticker資源
?? ?defer ticker.Stop()
?? ?// 循環(huán)處理任務(wù)
?? ?for {
?? ??? ?// 等待Ticker的下一次觸發(fā)
?? ??? ?<-ticker.C
?? ??? ?// 執(zhí)行任務(wù)
?? ??? ?fmt.Println("Task executed at", time.Now())
?? ?}
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?// 創(chuàng)建一個(gè)定時(shí)器,每隔1秒觸發(fā)一次
?? ?ticker := time.NewTicker(1 * time.Second)
?? ?// 在函數(shù)退出時(shí)停止定時(shí)器
?? ?defer ticker.Stop()
?? ?// timer實(shí)現(xiàn)定時(shí)器(延遲執(zhí)行),這個(gè)定時(shí)器只會(huì)觸發(fā)一次,所以想要執(zhí)行定時(shí)任務(wù)需要放在for循環(huán)中
?? ?for {
?? ??? ?select {
?? ??? ?// 定時(shí)器觸發(fā)時(shí)執(zhí)行的任務(wù)
?? ??? ?case <-ticker.C:
?? ??? ??? ?fmt.Println("hello world", time.Now())
?? ??? ?}
?? ?}
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?ticker := time.NewTicker(1 * time.Second)
?? ?go func() {
?? ??? ?for range ticker.C {
?? ??? ??? ?fmt.Println("Hello World!")
?? ??? ?}
?? ?}()
?? ?time.Sleep(10 * time.Second)
?? ?ticker.Stop()
}

package main
import (
?? ?"fmt"
?? ?"time"
)
func main() {
?? ?done := make(chan bool)
?? ?ticker := time.NewTicker(1 * time.Second)
?? ?go func() {
?? ??? ?for {
?? ??? ??? ?select {
?? ??? ??? ?case <-done:
?? ??? ??? ??? ?ticker.Stop()
?? ??? ??? ??? ?return
?? ??? ??? ?case <-ticker.C:
?? ??? ??? ??? ?fmt.Println("Hello World!")
?? ??? ??? ?}
?? ??? ?}
?? ?}()
?? ?time.Sleep(10 *time.Second)
?? ?done <- true
}

go get -u github.com/go-co-op/gocron

s := gocron.NewScheduler(time.UTC)
s.Every(5).Seconds().Do(func(){ ... }) 
s.Every("5m").Do(func(){ ... })
s.Every(5).Days().Do(fu
s.Every(1).Month(1, 2, 3).Do(func(){ ... })
s.Every(1).Day().At("10:30").Do(func(){ ... })
s.Every(1).Day().At("10:30;08:00").Do(func(){ ... })
s.Every(1).Day().At("10:30").At("08:00").Do(func(){ ... })
s.Every(1).MonthLastDay().Do(func(){ ... })
s.Every(2).MonthLastDay().Do(func(){ ... })
s.Cron("*/1 * * * *").Do(task) 
s.StartAsync()
s.StartBlocking()

package main
import (
?? ?"fmt"
?? ?"time"
?? ?"github.com/go-co-op/gocron"
)
func cron1() {
?? ?fmt.Println("cron1",time.Now())
}
func cron2() {
?? ?fmt.Println("cron2",time.Now())
}
func main() {
?? ?timezone, _ := time.LoadLocation("Asia/Shanghai")
?? ?s := gocron.NewScheduler(timezone)
?? ?// 每秒執(zhí)行一次
?? ?s.Every(1).Seconds().Do(func() {
?? ??? ?go cron1()
?? ?})
?? ?// 每秒執(zhí)行一次
?? ?s.Every(1).Second().Do(func() {
?? ??? ?go cron2()
?? ?})
?? ?s.StartBlocking()
}