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

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結構體的最小堆（四叉樹），排序關鍵字為執(zhí)行時間，即該定時任務下一次執(zhí)行的時間
   if !tb.created {
      tb.created = true
      go timerproc(tb)// 如果還沒有創(chuàng)建過管理定時任務的協(xié)程，則創(chuàng)建一個，執(zhí)行通知管理timer的協(xié)程，最核心代碼
   }
}

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

func timerproc(tb *timersBucket) {
   for {
      lock(tb.lock) //加鎖
      now := nanotime()  //當前時間的納秒值
      delta := int64(-1)  //最近要執(zhí)行的timer和當前時間的差值
      for {
         if len(tb.t) == 0 {
            delta = -1
            break
         }//當前無可執(zhí)行timer,直接跳出該循環(huán)
         t := tb.t[0]
         delta = t.when - now //取when組小的的timer，計算于當前時間的差值
         if delta > 0 {
            break
         }// delta大于0，說明還未到發(fā)送channel時間，需要跳出循環(huán)去睡眠delta時間
         if t.period > 0 {
            // leave in heap but adjust next time to fire
            t.when += t.period * (1 + -delta/t.period)// 計算該timer下次執(zhí)行任務的時間
            siftdownTimer(tb.t, 0) //調整堆
         } else {
            // remove from heap，如果沒有設定下次執(zhí)行時間，則將該timer從堆中移除（time.after和time.sleep函數(shù)即是只執(zhí)行一次定時任務）
            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中發(fā)送time結構體,喚醒阻塞的協(xié)程
         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時間，喚醒之后就可以執(zhí)行在堆頂?shù)亩〞r任務了
   }
}

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

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())
                }
        }
}