定时器和时间轮系列(一): 初识

func delayOnce() {
    n := time.Now()
    fmt.Println("delayOnce start, ", n)




    // delay 1 second
    <-time.After(time.Second)
    fmt.Println("Cost ", time.Since(n))
}




func delayTicker() {
    n := time.Now()
    fmt.Println("delayTicker start, ", n)




    // ticker 1 second, 3 times
    t := time.NewTicker(time.Second)
    for i := 0; i < 3; i++ {
        <-t.C
        fmt.Println("Tick ", time.Since(n))
    }




    t.Stop()
    fmt.Println("Cost ", time.Since(n))
}

// Add a timer to the heap and start or kick timerproc if the new timer is
// earlier than any of the others.
// Timers are locked.
func addtimerLocked(t *timer) {
    // ...
    t.i = len(timers.t)
    timers.t = append(timers.t, t)
    siftupTimer(t.i)
    if t.i == 0 {
        // siftup moved to top: new earliest deadline.
        if timers.sleeping {
            timers.sleeping = false
            notewakeup(&timers.waitnote)
        }
        // ...
    }
    if !timers.created {
        timers.created = true
        go timerproc()
    }
}

// Timerproc runs the time-driven events.
// It sleeps until the next event in the timers heap.
// If addtimer inserts a new earlier event, it wakes timerproc early.
func timerproc() {
    timers.gp = getg()
    for {
        // ...
        for {
            // ...
            t := timers.t[0]
            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
                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(arg, seq)
        }
        // ...




        // At least one timer pending. Sleep until then.
        timers.sleeping = true
        timers.sleepUntil = now + delta
        notetsleepg(&timers.waitnote, delta)
    }
}

func (t *timer) assignBucket() *timersBucket {
    id := uint8(getg().m.p.ptr().id) % timersLen
    t.tb = &timers[id].timersBucket
    return t.tb
}




func addtimer(t *timer) {
    tb := t.assignBucket()
    lock(&tb.lock)
    ok := tb.addtimerLocked(t)
    unlock(&tb.lock)
    if !ok {
        badTimer()
    }
}

func onConnect(ctx context.Context, i int) {
    t := time.NewTicker(time.Second)
    n := time.Now()
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Done")
            return
        case <-t.C:
            fmt.Printf("Tick[%v] %v\n", i, time.Since(n))
        }
    }
}




func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()




    for i := 0; i < 10; i++ {
        go onConnect(ctx, i)
    }




    <-ctx.Done()
    time.Sleep(time.Second) // wait all sub goroutine exit, should use WaitGroup
}