golang 定時任務方面time.Sleep和time.Tick的優劣對比分析

for {
   time.Sleep(time.Second)
   fmt.Println("我在定時執行任務")
}

t1:=time.Tick(3*time.Second)
for {
   select {
   case <-t1:
      fmt.Println("t1定時器")
   }
}

t:=time.NewTicker(time.Second)
for {
   select {
   case <-t.C:
      fmt.Println("t1定時器")
      t.Stop()
   }
}

func (tb *timersBucket) addtimerLocked(t *timer) {
   t.i = len(tb.t)  //計算timersBucket中，當前定時任務的長度
   tb.t = append(tb.t, t)// 將當前定時任務加入timersBucket
   siftupTimer(tb.t, t.i)  //維護一個timer結構體的最小堆（四叉樹），排序關鍵字為執行時間，即該定時任務下一次執行的時間
   if !tb.created {
      tb.created = true
      go timerproc(tb)// 如果還沒有創建過管理定時任務的協程，則創建一個，執行通知管理timer的協程，最核心代碼
   }
}

type timersBucket struct {
   lock         mutex //添加新定時任務時需要加鎖（沖突點在於維護堆）
   t            []*timer //timer切片，構造方式為四叉樹最小堆
}

func timerproc(tb *timersBucket) {
   for {
      lock(&tb.lock) //加鎖
      now := nanotime()  //當前時間的納秒值
      delta := int64(-1)  //最近要執行的timer和當前時間的差值
      for {
         if len(tb.t) == 0 {
            delta = -1
            break
         }//當前無可執行timer,直接跳出該循環
         t := tb.t[0]
         delta = t.when - now //取when組小的的timer，計算於當前時間的差值
         if delta > 0 {
            break
         }// delta大於0，說明還未到發送channel時間，需要跳出循環去睡眠delta時間
         if t.period > 0 {
            // leave in heap but adjust next time to fire
            t.when += t.period * (1 + -delta/t.period)// 計算該timer下次執行任務的時間
            siftdownTimer(tb.t, 0) //調整堆
         } else {
            // remove from heap，如果沒有設定下次執行時間，則將該timer從堆中移除（time.after和time.sleep函數即是隻執行一次定時任務）
            last := len(tb.t) - 1
            if last > 0 {
               tb.t[0] = tb.t[last]
               tb.t[0].i = 0
            }
            tb.t[last] = nil
            tb.t = tb.t[:last]
            if last > 0 {
               siftdownTimer(tb.t, 0)
            }
            t.i = -1 // mark as removed
         }
         f := t.f
         arg := t.arg
         seq := t.seq
         unlock(&tb.lock)//解鎖
         f(arg, seq) //在channel中發送time結構體,喚醒阻塞的協程
         lock(&tb.lock)
      }
      if delta < 0  {
         // No timers left - put goroutine to sleep.
         goparkunlock(&tb.lock, "timer goroutine (idle)", traceEvGoBlock, 1)
         continue
      }// delta小於0說明當前無定時任務，直接進行阻塞進行睡眠
      tb.sleeping = true
      tb.sleepUntil = now + delta
      unlock(&tb.lock)
      notetsleepg(&tb.waitnote, delta)  //睡眠delta時間，喚醒之後就可以執行在堆頂的定時任務瞭
   }
}

//go:linkname timeSleep time.Sleep
func timeSleep(ns int64) {
   *t = timer{} //創建一個定時任務
   t.when = nanotime() + ns //計算定時任務的執行時間點
   t.f = goroutineReady //執行方法
   tb.addtimerLocked(t)  //加入timer堆，並在timer定時任務執行協程中等待被執行
   goparkunlock(&tb.lock, "sleep", traceEvGoSleep, 2) //睡眠，等待定時任務協程通知喚醒
}

package main
import (
        "fmt"
        "time"
)
func main() {
        d := time.Duration(time.Second*2)
        t := time.NewTicker(d)
        defer t.Stop()
        for {
                <- t.C
                fmt.Println("timeout...")
        }
}

package main
import (
        "fmt"
        "time"
)
func main() {
        d := time.Duration(time.Second*2)
        t := time.NewTimer(d)
        defer t.Stop()
        for {
                <- t.C
                fmt.Println("timeout...")
  // need reset
  t.Reset(time.Second*2)
        }
}

package main
import (
        "fmt"
        "time"
)
func main() {
        t := time.NewTicker(3*time.Second)
        defer t.Stop()
        fmt.Println(time.Now())
        time.Sleep(4*time.Second)
        for {
                select {
                case <-t.C:
                        fmt.Println(time.Now())
                }
        }
}