go中的定时器timer

package main

import (
  "time"
  "fmt"
)

func main() {
  a := time.After(2 * time.Second)
  <- a
  fmt.Println("timer receive")

  time.AfterFunc(2 * time.Second, func(){
    fmt.Println("timer receive")
  })
}

  //time/sleep.go
 func AfterFunc(d Duration, f func()) *Timer {
    t := &Timer{
      r: runtimeTimer{
    when: when(d),
    f:    goFunc,
    arg:  f,
      },
    }
    startTimer(&t.r)
    return t
  } 
  func goFunc(arg interface{}, seq uintptr) {
      go arg.(func())()
}

//runtime/time.go
  func startTimer(t *timer) {
    if raceenabled {
      racerelease(unsafe.Pointer(t))
    }
    addtimer(t)
  }

  func addtimer(t *timer) {
    lock(&timers.lock)
    addtimerLocked(t)
    unlock(&timers.lock)
  }

  // Add a timer to the heap and start or kick the timer proc.
  // If the new timer is earlier than any of the others.
  // Timers are locked.
  func addtimerLocked(t *timer) {
    // when must never be negative; otherwise timerproc will overflow
    // during its delta calculation and never expire other runtime·timers.
    if t.when < 0 {
      t.when = 1<<63 - 1
    }
    //添加time到全局timer
    t.i = len(timers.t)
    timers.t = append(timers.t, t)
    //使用最小堆算法维护timer队列
    siftupTimer(t.i)
    //如果是第一个
    if t.i == 0 {
      // siftup moved to top: new earliest deadline.
      //如果在sleep中, 唤醒
      if timers.sleeping {
    timers.sleeping = false
    notewakeup(&timers.waitnote)
      }
      //如果在调度中, 等待
      if timers.rescheduling {
    timers.rescheduling = false
    goready(timers.gp, 0)
      }
    }
    //如果timer还没创建,则创建
    if !timers.created {
      timers.created = true
      go timerproc()
    }
  }

func timerproc() {
  timers.gp = getg()
  for {
    lock(&timers.lock)
    timers.sleeping = false
    now := nanotime()
    delta := int64(-1)
    for {
      if len(timers.t) == 0 {
    delta = -1
    break
      }
      t := timers.t[0]
      //得到剩余时间, 还没到时间就sleep
      delta = t.when - now
      if delta > 0 {
    break
      }
      //如果是周期性的就算下一次时间
      if t.period > 0 {
    // leave in heap but adjust next time to fire
    t.when += t.period * (1 + -delta/t.period)
    //最小堆下沉
    siftdownTimer(0)
      } else {
    // remove from heap
    //删除将要执行的timer,(最小堆算法)
    last := len(timers.t) - 1
    if last > 0 {
      timers.t[0] = timers.t[last]
      timers.t[0].i = 0
    }
    timers.t[last] = nil
    timers.t = timers.t[:last]
    if last > 0 {
      siftdownTimer(0)
    }
    t.i = -1 // mark as removed
      }
      f := t.f
      arg := t.arg
      seq := t.seq
      unlock(&timers.lock)
      if raceenabled {
    raceacquire(unsafe.Pointer(t))
      }
      //执行函数调用函数
      f(arg, seq)
      lock(&timers.lock)
    }
    //继续下一个,因为可能下一个timer也到时间了
    if delta < 0 || faketime > 0 {
      // No timers left - put goroutine to sleep.
      timers.rescheduling = true
      goparkunlock(&timers.lock, "timer goroutine (idle)", traceEvGoBlock, 1)
      continue
    }
    // At least one timer pending.  Sleep until then.
    timers.sleeping = true
    noteclear(&timers.waitnote)
    unlock(&timers.lock)
    //没到时间,睡眠delta时间
    notetsleepg(&timers.waitnote, delta)
  }
}