perf: use min-heap from robfig/pull/423

Author: fufuok

cron.go

@@ -1,8 +1,8 @@
 package cron
 
 import (
+	"container/heap"
 	"context"
-	"sort"
 	"sync"
 	"time"
 )
@@ -11,7 +11,7 @@ import (
 // specified by the schedule. It may be started, stopped, and the entries may
 // be inspected while running.
 type Cron struct {
-	entries   []*Entry
+	entries   EntryHeap
 	chain     Chain
 	stop      chan struct{}
 	add       chan *Entry
@@ -97,17 +97,17 @@ func (s byTime) Less(i, j int) bool {
 //
 // Available Settings
 //
-//   Time Zone
-//     Description: The time zone in which schedules are interpreted
-//     Default:     time.Local
+//	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
+//	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.
+//	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.
 func New(opts ...Option) *Cron {
@@ -166,7 +166,7 @@ func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID {
 		Job:        cmd,
 	}
 	if !c.running {
-		c.entries = append(c.entries, entry)
+		heap.Push(&c.entries, entry)
 	} else {
 		c.add <- entry
 	}
@@ -241,14 +241,19 @@ func (c *Cron) run() {
 
 	// Figure out the next activation times for each entry.
 	now := c.now()
-	for _, entry := range c.entries {
+	sortedEntries := new(EntryHeap)
+	for len(c.entries) > 0 {
+		entry := heap.Pop(&c.entries).(*Entry)
 		entry.Next = entry.Schedule.Next(now)
+		heap.Push(sortedEntries, entry)
 		c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next)
 	}
+	c.entries = *sortedEntries
 
 	for {
 		// Determine the next entry to run.
-		sort.Sort(byTime(c.entries))
+		// User min-heap no need sort anymore
+		// sort.Sort(byTime(c.entries))
 
 		var timer *time.Timer
 		if len(c.entries) == 0 || c.entries[0].Next.IsZero() {
@@ -266,21 +271,24 @@ func (c *Cron) run() {
 				c.logger.Info("wake", "now", now)
 
 				// Run every entry whose next time was less than now
-				for _, e := range c.entries {
+				for {
+					e := c.entries.Peek()
 					if e.Next.After(now) || e.Next.IsZero() {
 						break
 					}
+					e = heap.Pop(&c.entries).(*Entry)
 					c.startJob(e.WrappedJob)
 					e.Prev = e.Next
 					e.Next = e.Schedule.Next(now)
+					heap.Push(&c.entries, e)
 					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)
+				heap.Push(&c.entries, newEntry)
 				c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next)
 
 			case replyChan := <-c.snapshot:
@@ -345,11 +353,10 @@ func (c *Cron) entrySnapshot() []Entry {
 }
 
 func (c *Cron) removeEntry(id EntryID) {
-	var entries []*Entry
-	for _, e := range c.entries {
-		if e.ID != id {
-			entries = append(entries, e)
+	for idx, e := range c.entries {
+		if e.ID == id {
+			heap.Remove(&c.entries, idx)
+			return
 		}
 	}
-	c.entries = entries
 }

cron_test.go

@@ -2,6 +2,7 @@ package cron
 
 import (
 	"bytes"
+	"container/heap"
 	"fmt"
 	"log"
 	"strings"
@@ -466,9 +467,13 @@ func TestJob(t *testing.T) {
 	expecteds := []string{"job2", "job4", "job5", "job1", "job3", "job0"}
 
 	var actuals []string
-	for _, entry := range cron.Entries() {
+	clone := new(EntryHeap)
+	for len(cron.entries) > 0 {
+		entry := heap.Pop(&cron.entries).(*Entry)
 		actuals = append(actuals, entry.Job.(testJob).name)
+		heap.Push(clone, entry)
 	}
+	cron.entries = *clone
 
 	for i, expected := range expecteds {
 		if actuals[i] != expected {

entry_heap.go

@@ -0,0 +1,37 @@
+package cron
+
+type EntryHeap []*Entry
+
+func (h *EntryHeap) Less(i, j int) bool {
+	if (*h)[i].Next.IsZero() {
+		return false
+	}
+	if (*h)[j].Next.IsZero() {
+		return true
+	}
+	return (*h)[i].Next.Before((*h)[j].Next)
+}
+
+func (h *EntryHeap) Swap(i, j int) {
+	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
+}
+
+func (h *EntryHeap) Len() int {
+	return len(*h)
+}
+
+func (h *EntryHeap) Pop() (v interface{}) {
+	*h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1]
+	return
+}
+
+func (h *EntryHeap) Push(v interface{}) {
+	*h = append(*h, v.(*Entry))
+}
+
+func (h *EntryHeap) Peek() *Entry {
+	if len(*h) == 0 {
+		return nil
+	}
+	return (*h)[0]
+}