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

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中，當(dāng)前定時任務(wù)的長度
   tb.t = append(tb.t, t)// 將當(dāng)前定時任務(wù)加入timersBucket
   siftupTimer(tb.t, t.i)  //維護一個timer結(jié)構(gòu)體的最小堆（四叉樹），排序關(guān)鍵字為執(zhí)行時間，即該定時任務(wù)下一次執(zhí)行的時間
   if !tb.created {
      tb.created = true
      go timerproc(tb)// 如果還沒有創(chuàng)建過管理定時任務(wù)的協(xié)程，則創(chuàng)建一個，執(zhí)行通知管理timer的協(xié)程，最核心代碼
   }
}

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

func timerproc(tb *timersBucket) {
   for {
      lock(&tb.lock) //加鎖
      now := nanotime()  //當(dāng)前時間的納秒值
      delta := int64(-1)  //最近要執(zhí)行的timer和當(dāng)前時間的差值
      for {
         if len(tb.t) == 0 {
            delta = -1
            break
         }//當(dāng)前無可執(zhí)行timer,直接跳出該循環(huán)
         t := tb.t[0]
         delta = t.when - now //取when組小的的timer，計算于當(dāng)前時間的差值
         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í)行任務(wù)的時間
            siftdownTimer(tb.t, 0) //調(diào)整堆
         } else {
            // remove from heap，如果沒有設(shè)定下次執(zhí)行時間，則將該timer從堆中移除（time.after和time.sleep函數(shù)即是只執(zhí)行一次定時任務(wù)）
            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結(jié)構(gòu)體,喚醒阻塞的協(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說明當(dāng)前無定時任務(wù)，直接進行阻塞進行睡眠
      tb.sleeping = true
      tb.sleepUntil = now + delta
      unlock(&tb.lock)
      notetsleepg(&tb.waitnote, delta)  //睡眠delta時間，喚醒之后就可以執(zhí)行在堆頂?shù)亩〞r任務(wù)了
   }
}

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