Go官方库源码分析：time/rate

   r := rate.Every(100 * time.Millisecond)   limit := rate.NewLimiter(r, 20)   for {       if limit.AllowN(time.Now(), 8) {           log.Info("log:event happen")       } else {           log.Info("log:event not allow")       }
   }

rate.gorate_test.go

// NewLimiter returns a new Limiter that allows events up to rate r and permits// bursts of at most b tokens.func NewLimiter(r Limit, b int) *Limiter {  return &Limiter{    limit: r,    burst: b,  }}

type Limiter struct {  mu     sync.Mutex  limit  Limit  burst  int  tokens float64  // last is the last time the limiter's tokens field was updated  last time.Time  // lastEvent is the latest time of a rate-limited event (past or future)  lastEvent time.Time}

func Every(interval time.Duration) Limit {  if interval <= 0 {    return Inf  }  return 1 / Limit(interval.Seconds())}

// Allow is shorthand for AllowN(time.Now(), 1).func (lim *Limiter) Allow() bool {  return lim.AllowN(time.Now(), 1)}
// AllowN reports whether n events may happen at time now.// Use this method if you intend to drop / skip events that exceed the rate limit.// Otherwise use Reserve or Wait.func (lim *Limiter) AllowN(now time.Time, n int) bool {  return lim.reserveN(now, n, 0).ok}

// reserveN is a helper method for AllowN, ReserveN, and WaitN.// maxFutureReserve specifies the maximum reservation wait duration allowed.// reserveN returns Reservation, not *Reservation, to avoid allocation in AllowN and WaitN.func (lim *Limiter) reserveN(now time.Time, n int, maxFutureReserve time.Duration) Reservation {  lim.mu.Lock()
  if lim.limit == Inf {    lim.mu.Unlock()    return Reservation{      ok:        true,      lim:       lim,      tokens:    n,      timeToAct: now,    }  }
  now, last, tokens := lim.advance(now)
  // Calculate the remaining number of tokens resulting from the request.  tokens -= float64(n)
  // Calculate the wait duration  var waitDuration time.Duration  if tokens < 0 {    waitDuration = lim.limit.durationFromTokens(-tokens)  }
  // Decide result  ok := n <= lim.burst && waitDuration <= maxFutureReserve
  // Prepare reservation  r := Reservation{    ok:    ok,    lim:   lim,    limit: lim.limit,  }  if ok {    r.tokens = n    r.timeToAct = now.Add(waitDuration)  }
  // Update state  if ok {    lim.last = now    lim.tokens = tokens    lim.lastEvent = r.timeToAct  } else {    lim.last = last  }
  lim.mu.Unlock()  return r}

// A Reservation holds information about events that are permitted by a Limiter to happen after a delay.// A Reservation may be canceled, which may enable the Limiter to permit additional events.type Reservation struct {  ok        bool  lim       *Limiter  tokens    int  timeToAct time.Time  // This is the Limit at reservation time, it can change later.  limit Limit}

// advance calculates and returns an updated state for lim resulting from the passage of time.// lim is not changed.// advance requires that lim.mu is held.func (lim *Limiter) advance(now time.Time) (newNow time.Time, newLast time.Time, newTokens float64) {  last := lim.last  if now.Before(last) {    last = now  }
  // Calculate the new number of tokens, due to time that passed.  elapsed := now.Sub(last)  delta := lim.limit.tokensFromDuration(elapsed)  tokens := lim.tokens + delta  if burst := float64(lim.burst); tokens > burst {    tokens = burst  }  return now, last, tokens}

 delta := lim.limit.tokensFromDuration(elapsed)

type Limit float64// tokensFromDuration is a unit conversion function from a time duration to the number of tokens// which could be accumulated during that duration at a rate of limit tokens per second.func (limit Limit) tokensFromDuration(d time.Duration) float64 {  return d.Seconds() * float64(limit)}

ok := n <= lim.burst && waitDuration <= maxFutureReserve

func (lim *Limiter) Allow() boolfunc (lim *Limiter) AllowN(now time.Time, n int) bool

func (lim *Limiter) Wait(ctx context.Context) (err error)func (lim *Limiter) WaitN(ctx context.Context, n int) (err error)

// WaitN blocks until lim permits n events to happen.// It returns an error if n exceeds the Limiter's burst size, the Context is// canceled, or the expected wait time exceeds the Context's Deadline.// The burst limit is ignored if the rate limit is Inf.func (lim *Limiter) WaitN(ctx context.Context, n int) (err error) {  lim.mu.Lock()  burst := lim.burst  limit := lim.limit  lim.mu.Unlock()
  if n > burst && limit != Inf {    return fmt.Errorf("rate: Wait(n=%d) exceeds limiter's burst %d", n, burst)  }  // Check if ctx is already cancelled  select {  case <-ctx.Done():    return ctx.Err()  default:  }  // Determine wait limit  now := time.Now()  waitLimit := InfDuration  if deadline, ok := ctx.Deadline(); ok {    waitLimit = deadline.Sub(now)  }  // Reserve  r := lim.reserveN(now, n, waitLimit)  if !r.ok {    return fmt.Errorf("rate: Wait(n=%d) would exceed context deadline", n)  }  // Wait if necessary  delay := r.DelayFrom(now)  if delay == 0 {    return nil  }  t := time.NewTimer(delay)  defer t.Stop()  select {  case <-t.C:    // We can proceed.    return nil  case <-ctx.Done():    // Context was canceled before we could proceed.  Cancel the    // reservation, which may permit other events to proceed sooner.    r.Cancel()    return ctx.Err()  }}

// DelayFrom returns the duration for which the reservation holder must wait// before taking the reserved action.  Zero duration means act immediately.// InfDuration means the limiter cannot grant the tokens requested in this// Reservation within the maximum wait time.func (r *Reservation) DelayFrom(now time.Time) time.Duration {  if !r.ok {    return InfDuration  }  delay := r.timeToAct.Sub(now)  if delay < 0 {    return 0  }  return delay}

func (lim *Limiter) Reserve() *Reservationfunc (lim *Limiter) ReserveN(now time.Time, n int) *Reservation

func (lim *Limiter) ReserveN(now time.Time, n int) *Reservation {  r := lim.reserveN(now, n, InfDuration)  return &r}