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