func (tb *timersBucket) 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
      }
      t.i = len(tb.t)
      tb.t = append(tb.t, t)
      // 执行堆化操作
      siftupTimer(tb.t, t.i)
      // 当前事件最先触发deadline
      if t.i == 0 {
          // siftup moved to top: new earliest deadline.
          if tb.sleeping {
               tb.sleeping = false
               // 唤醒定时器futex睡眠
               notewakeup(&tb.waitnote)
          }
          if tb.rescheduling {
               tb.rescheduling = false
               goready(tb.gp, 0)
          }
      }
      // 启动定时器loop协程
      if !tb.created {
           tb.created = true
           go timerproc(tb)
      }
}

  // timer gorutine 周期性的管理二叉堆
  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]
  			delta = t.when - now
            // 需要休眠等待到expire时间点
  			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
  				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)
  		}
  		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)
        // 调用futex休眠等待到delta超时时间
  		notetsleepg(&timers.waitnote, delta)
  	}
  }

  func futexsleep(addr *uint32, val uint32, ns int64) {
  	var ts timespec

  	if ns < 0 {
  		futex(unsafe.Pointer(addr), _FUTEX_WAIT, val, nil, nil, 0)
  		return
  	}

  	if sys.PtrSize == 8 {
  		ts.set_sec(ns / 1000000000)
  		ts.set_nsec(int32(ns % 1000000000))
  	} else {
  		ts.tv_nsec = 0
  		ts.set_sec(int64(timediv(ns, 1000000000, (*int32)(unsafe.Pointer(&ts.tv_nsec)))))
  	}
  	futex(unsafe.Pointer(addr), _FUTEX_WAIT, val, unsafe.Pointer(&ts), nil, 0)
  }

  // 定时器loop协程
  func  timerproc() {
      loop {
          delta = getMinTimerHeapDelta()
          // 线程睡眠时间片 10e6 纳秒 = 1 微秒
          ns = 10e6 
          for n in [1..delta/ns] {
              // 当其他gorutine添加deadline更近的事件时调用notewakeup() 
              // 唤醒futex的线程 处理deadline更近的事件
              if wake_by_other || delta <= 0 {
                  break
              }
              if delta < ns {
                  ns = delta
              }
              // 调用futex 睡眠 1 微秒
              notesleepng(ns)
              delta -= ns
          }
      }
  }