定时任务 执行频率保证

 

// 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{}

    add      chan *Entry

    remove   chan EntryID

    snapshot chan chan []Entry

    running  bool

    // logger       Logger

    logger    *klog.Helper

    runningMu sync.Mutex

    location  *time.Location

    parser    ScheduleParser

    nextID    EntryID

    jobWaiter sync.WaitGroup

}

 

github.com/robfig/cron/v3

 

// 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

        }

    }

}

 

 

 

 

搜索

复制