go限流组件包rate源码分析

// 使用golang/rate 实现, 令牌桶算法
func TestRateLimitByGoRate1(t *testing.T) {
	ticker := rate.NewLimiter(3, 6)
	length := 20
	chs := make([]chan string, length)
	for i := 0; i < length; i++ {
		chs[i] = make(chan string, 1)
		go func(taskId string, ch chan string, r *rate.Limiter) {
			err := ticker.Wait(context.TODO())
			if err != nil {
				ch <- "Task-" + taskId + " not allow " + time.Now().Format(layout)
			}

			time.Sleep(time.Duration(5) * time.Millisecond)
			ch <- "Task-" + taskId + " run success  " + time.Now().Format(layout)
			return

		}(strconv.FormatInt(int64(i), 10), chs[i], ticker)
	}
	for _, ch := range chs {
		t.Log("task start at " + <-ch)
	}
}

=== RUN   TestRateLimitByGoRate1
    rateLimit_test.go:121: task start at Task-0 run success  2021-07-07 16:13:06
    rateLimit_test.go:121: task start at Task-1 run success  2021-07-07 16:13:06
    rateLimit_test.go:121: task start at Task-2 run success  2021-07-07 16:13:07
    rateLimit_test.go:121: task start at Task-3 run success  2021-07-07 16:13:10
    rateLimit_test.go:121: task start at Task-4 run success  2021-07-07 16:13:08
    rateLimit_test.go:121: task start at Task-5 run success  2021-07-07 16:13:08
    rateLimit_test.go:121: task start at Task-6 run success  2021-07-07 16:13:11
    rateLimit_test.go:121: task start at Task-7 run success  2021-07-07 16:13:06
    rateLimit_test.go:121: task start at Task-8 run success  2021-07-07 16:13:06
    rateLimit_test.go:121: task start at Task-9 run success  2021-07-07 16:13:06
    rateLimit_test.go:121: task start at Task-10 run success  2021-07-07 16:13:07
    rateLimit_test.go:121: task start at Task-11 run success  2021-07-07 16:13:09
    rateLimit_test.go:121: task start at Task-12 run success  2021-07-07 16:13:11
    rateLimit_test.go:121: task start at Task-13 run success  2021-07-07 16:13:09
    rateLimit_test.go:121: task start at Task-14 run success  2021-07-07 16:13:07
    rateLimit_test.go:121: task start at Task-15 run success  2021-07-07 16:13:08
    rateLimit_test.go:121: task start at Task-16 run success  2021-07-07 16:13:09
    rateLimit_test.go:121: task start at Task-17 run success  2021-07-07 16:13:10
    rateLimit_test.go:121: task start at Task-18 run success  2021-07-07 16:13:10
    rateLimit_test.go:121: task start at Task-19 run success  2021-07-07 16:13:06
--- PASS: TestRateLimitByGoRate1 (4.67s)
PASS

type Reservation struct {
  // 表示是否预订成功
   ok        bool
  // 限流器
   lim       *Limiter
  // 当前tokens数
   tokens    int
  // 需要等待的截止时间
   timeToAct time.Time
   // This is the Limit at reservation time, it can change later.
  // 预订的时间
   limit Limit
}

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,
		}
	}

  // step1. 计算截止当前时间now, 桶里面还有多少token。
	now, last, tokens := lim.advance(now)

  // step2. 计算还需要生成多少token才够n个token
	// Calculate the remaining number of tokens resulting from the request.
	tokens -= float64(n)
	// Calculate the wait duration
	var waitDuration time.Duration
	if tokens < 0 {
    // 生成tokens个令牌需要等待多长时间
		waitDuration = lim.limit.durationFromTokens(-tokens)
	}

  // step3. 如果等待时间超过了用户的maxFutureReserve，则表示预订失败，直接返回
  // 否则返回预定成功，并告知用户交货的时间timeToAct。
	// 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
}

func (lim *Limiter) advance(now time.Time) (newNow time.Time, newLast time.Time, newTokens float64) {
	last := lim.last
	if now.Before(last) {
		last = now
	}
	// Avoid making delta overflow below when last is very old.
	maxElapsed := lim.limit.durationFromTokens(float64(lim.burst) - lim.tokens)
	elapsed := now.Sub(last)
	if elapsed > maxElapsed {
		elapsed = maxElapsed
	}

	// Calculate the new number of tokens, due to time that passed.
	delta := lim.limit.tokensFromDuration(elapsed)
	tokens := lim.tokens + delta
	if burst := float64(lim.burst); tokens > burst {
		tokens = burst
	}

  // 返回当前时间， 上一次领取时间，当前桶里面已经有的tokens
	return now, last, tokens
}

func (limit Limit) tokensFromDuration(d time.Duration) float64 {
	// Split the integer and fractional parts ourself to minimize rounding errors.
	// See golang.org/issues/34861.
	sec := float64(d/time.Second) * float64(limit)
	nsec := float64(d%time.Second) * float64(limit)
	return sec + nsec/1e9
}