服務治理：幾種開源限流演算法庫/應用軟體介紹和使用

一、Go time/rate 限流器

1.1 簡介

Go 在 x 標準庫，即 golang.org/x/time/rate 裡自帶了一個限流器，這個限流器是基於令牌桶演算法（token bucket）實現的。

在上一篇文章講了幾種限流演算法，裡面就有令牌桶演算法，具體可以看上篇文章介紹。

1.2 rate/time 限流構造器

這個限流構造器就是生成 token，供後面使用。

Limiter struct 結構：

// https://github.com/golang/time/blob/master/rate/rate.go#L55

// The methods AllowN, ReserveN, and WaitN consume n tokens.
type Limiter struct {
    mu sync.Mutex
    limit Limit   // 放入 token 的速率
    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 NewLimiter(r Limit, b int) *Limiter：

• r ：產生 token 的速率。預設是每秒中可以向桶中生產多少 token。也可以設定這個值，用方法 Every 設定 token 速率時間粒度。
• b ：桶的容量，桶容納 token 的最大數量。 b == 0，允許宣告容量為 0 的值，這時拒絕所有請求；與 b== 0 情況相反，如果 r 為 inf 時，將允許所有請求，即使是 b == 0。

// Inf is the infinite rate limit; it allows all events (even if burst is zero). 
const Inf = Limit(math.MaxFloat64)

It implements a "token bucket" of size b, initially full and refilled at rate r tokens per second.
構造器一開始會為桶注入 b 個 token，然後每秒補充 r 個 token。

• 每秒生成 20 個 token，桶的容量為 5，程式碼為：

limiter ：= NewLimiter(20, 5)

• 200ms 生成 1 個 token

這時候不是秒為單位生成 token ，就可以使用 Every 方法設定生成 token 的速率：

limit := Every(200 * time.Millisecond)
limiter := NewLimiter(limit, 5)

1秒 = 200ms * 5，也就是每秒生成 5 個 token。

生成了 token 之後，請求獲取 token，然後使用 token。

1.3 time/rate 有3種限流用法

time/rate 原始碼裡註釋，消費 n 個 tokens 的方法

// The methods AllowN, ReserveN, and WaitN consume n tokens.

• AllowN
• ReserveN
• WaitN

A. WaitN、Wait

WaitN / Wait 方法：

// https://pkg.go.dev/golang.org/x/time/rate#Limiter.WaitN
// 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)

func (lim *Limiter) Wait(ctx context.Context) (err error)

WaitN ： 當桶中的 token 數量小於 N 時，WaitN 方法將阻塞一段時間直到 token 滿足條件或超時或取消(如果設定了context)，超時或取消將返回error。如果 N 充足則直接返回。
Wait ： 就是 WaitN 方法中引數 n 為 1 時，即：WaitN(ctx, 1)。

方法裡還有 Contex 引數，所以也可以設定 Deadline 或 Timeout，來決定 Wait 最長時間。比如下面程式碼片段：

 ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
 defer cancel()
 err := limiter.WaitN(ctx, 2)

例子1：

package main

import (
	"context"
	"fmt"
	"time"

	"golang.org/x/time/rate"
)

func main() {
	limit := rate.NewLimiter(3, 5) // 每秒產生 3 個token，桶容量 5

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel() // 超時取消

	for i := 0; ; i++ { // 有多少令牌直接消耗掉
		fmt.Printf("%03d %s\n", i, time.Now().Format("2006-01-02 15:04:05.000"))
		err := limit.Wait(ctx)
		if err != nil { // 超時取消 err != nil
			fmt.Println("err: ", err.Error())
			return // 超時取消，退出 for
		}
	}
}

分析：這裡指定令牌桶大小為 5，每秒生成 3 個令牌。for 迴圈消耗令牌，產生多少令牌都會消耗掉。
從開始一直到 5 秒超時，計算令牌數，一開始初始化 NewLimiter 的 5 個 + 每秒 3 個令牌 * 5秒 ，總計 20 個令牌。執行程式輸出看看：

$ go run .\waitdemo.go
000 2022-05-17 21:35:38.400
001 2022-05-17 21:35:38.425
002 2022-05-17 21:35:38.425
003 2022-05-17 21:35:38.425
004 2022-05-17 21:35:38.425
005 2022-05-17 21:35:38.425
006 2022-05-17 21:35:38.773
007 2022-05-17 21:35:39.096
008 2022-05-17 21:35:39.436
009 2022-05-17 21:35:39.764
010 2022-05-17 21:35:40.106
011 2022-05-17 21:35:40.434
012 2022-05-17 21:35:40.762
013 2022-05-17 21:35:41.104
014 2022-05-17 21:35:41.430
015 2022-05-17 21:35:41.759
016 2022-05-17 21:35:42.104
017 2022-05-17 21:35:42.429
018 2022-05-17 21:35:42.773
019 2022-05-17 21:35:43.101
err:  rate: Wait(n=1) would exceed context deadline

B: AllowN、Allow

AllowN / Allow 方法

// https://pkg.go.dev/golang.org/x/time/rate#Limiter.AllowN
// 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

// Allow is shorthand for AllowN(time.Now(), 1).
func (lim *Limiter) Allow() bool

AllowN ：截止到某一時刻，桶中的 token 數量至少為 N 個，滿足就返回 true，同時從桶中消費 n 個 token；反之返回 false，不消費 token。這個實際就是丟棄某些請求。
Allow ：就是 AllowN 方法中引數 now 為現在時間，n 為 1，即 AllowN(time.Now(), 1)

例子：

package main

import (
	"fmt"
	"net/http"
	"time"

	"golang.org/x/time/rate"
)

func main() {
	r := rate.Every(1 * time.Millisecond)
	limit := rate.NewLimiter(r, 10)

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if limit.Allow() {
			fmt.Printf("success，當前時間：%s\n", time.Now().Format("2006-01-02 15:04:05"))
		} else {
			fmt.Printf("success，但是被限流了。。。\n")
		}
	})

	fmt.Println("http start ... ")
	_ = http.ListenAndServe(":8080", nil)

}

然後你可以找一個 http 測試工具模擬使用者壓測下，比如 https://github.com/rakyll/hey 這個工具。測試命令：

hey -n 100 http://localhost:8080/

就可以看到輸出的內容

... ...
success，當前時間：2022-05-17 21:41:44
success，當前時間：2022-05-17 21:41:44
success，當前時間：2022-05-17 21:41:44
success，但是被限流了。。。
success，但是被限流了。。。
... ...

例子2：

package main

import (
	"fmt"
	"time"

	"golang.org/x/time/rate"
)

func main() {
	limit := rate.NewLimiter(1, 3)
	for {
		if limit.AllowN(time.Now(), 2) {
			fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
		} else {
			time.Sleep(time.Second * 3)
		}
	}
}

C：ReserveN、Reserve

ReserveN / Reserve 方法

// https://pkg.go.dev/golang.org/x/time/rate#Limiter.ReserveN
// ReserveN returns a Reservation that indicates how long the caller must wait before n events happen. The Limiter takes this Reservation into account when allowing future events. The returned Reservation’s OK() method returns false if n exceeds the Limiter's burst size.
func (lim *Limiter) ReserveN(now time.Time, n int) *Reservation

func (lim *Limiter) Reserve() *Reservation

func (r *Reservation) DelayFrom(now time.Time) time.Duration
func (r *Reservation) Delay() time.Duration
func (r *Reservation) OK() bool

其實上面的 WaitN 和 AllowN 都是基於 ReserveN 方法。具體可以去看看這 3 個方法的原始碼。

ReserveN ：此方法返回 *Reservation 物件。你可以呼叫該物件的 Dealy 方法，獲取延遲等待的時間。如果為 0，則不用等待。必須等到等待時間結束後才能進行下面的工作。
或者，如果不想等待，可以呼叫 Cancel 方法，該方法會將 Token 歸還。
Reserve ：就是 ReserveN 方法中引數 now 為現在時間，n 為 1，即 AllowN(time.Now(), 1)

usage example:

// https://pkg.go.dev/golang.org/x/time/rate#Limiter.ReserveN

r := lim.ReserveN(time.Now(), 1)
if !r.OK() {
  // Not allowed to act! Did you remember to set lim.burst to be > 0 ?
  return
}
time.Sleep(r.Delay())
Act() // 執行相關邏輯

1.4 動態設定桶token容量和速率

SetBurstAt / SetBurst：

func (lim *Limiter) SetBurstAt(now time.Time, newBurst int)
func (lim *Limiter) SetBurst(newBurst int)

SetBurstAt ：設定到某時刻桶中 token 的容量
SetBurst：SetBurstAt(time.Now())

SetLimitAt / SetLimit

func (lim *Limiter) SetLimitAt(now time.Time, newLimit Limit)
func (lim *Limiter) SetLimit(newLimit Limit)

SetLimitAt ：設定某刻 token 的速率
SetLimit ：設定 token 的速率

二、uber 的 rate limiter

2.1 簡介

uber 的這個限流演算法是漏桶演算法（leaky bucket） - github.com/uber-go/ratelimit。

與令牌桶演算法的區別：

1. 漏桶演算法流出的速率可以控制，流進桶中請求不能控制
2. 令牌桶演算法對於流入和流出的速度都是可以控制的，因為令牌可以自己生成。所以它還可以應對突發流量。突發流量生成 token 就快些。
3. 令牌桶演算法只要桶中有 token 就可以一直消費，漏桶是按照預定的間隔順序進行消費的。

2.2 使用

官方的例子：

limit := ratelimit.New(100) // 每秒鐘允許100個請求

prev := time.Now()

for i := 0; i < 10; i++ {
    now := limit.Take()
    fmt.Println(i, now.Sub(prev))
    prev = now
}

限流器每秒可以通過 100 個請求，平均每個間隔 10ms。

2.3 uber 對漏桶演算法的改進

在傳統的漏桶演算法，每個請求間隔是固定的，然而在實際應用中，流量不是這麼平均的，時而小時而大，對於這種情況，uber 對 leaky bucket 做了一點改進，引入 maxSlack 最大鬆弛量的概念。

舉例子：比如 3 個請求，請求 1 完成，15ms後，請求 2 才到來，可以對 2 立即處理。請求 2 完成後，5ms後，請求 3 到來，這個請求距離上次請求不足 10ms，因此要等 5ms。
但是，對於這種情況，實際三個請求一共耗時 25ms 才完成，並不是預期的 20ms。

uber 的改進是：可以把之情請求間隔比較長的時間，勻給後面的請求使用，只要保證每秒請求數即可。

uber ratelimit 改進程式碼實現：

t.sleepFor += t.perRequest - now.Sub(t.last)
if t.sleepFor > 0 {
  t.clock.Sleep(t.sleepFor)
  t.last = now.Add(t.sleepFor)
  t.sleepFor = 0
} else {
  t.last = now
}

把每個請求多餘出來的等待時間累加起來，以給後面的抵消使用。

其他引數用法：

• WithoutSlack：

ratelimit 中引入最大鬆弛量，預設的最大鬆弛量為 10 個請求的間隔時間。
但是我不想用這個最大鬆弛量呢，就要限制請求的固定間隔時間，用 WithoutSlack 這個引數限制：

limit := ratelimit.New(100, ratelimit.WithoutSlack)

• WithClock(clock Clock)：

ratelimit 中時間相關計算是用 go 的標準時間庫 time，如果想要更高進度或特殊需求計算，可以用 WithClock 引數替換，實現 Clock 的 interface 就可以了

type Clock interface {
        Now() time.Time
        Sleep(time.Duration)
}

clock &= MyClock{}
limiter := ratelimit.New(100, ratelimit.WithClock(clock))

更多 ratelimit

三、其他限流器，演算法庫包和軟體

1. 滴滴的 tollbooth，http 限流中介軟體，有很多特性：
   • 1.基於IP，路徑，方法，header，授權使用者等限流
   • 2.通過使用 LimitByKeys() 組合你自己的中介軟體
   • 3.對於head項和基本auth能夠設定TTL-過期時間
   • 4.拒絕後，可以使用以下 HTTP 頭響應，比如 X-Rate-Limit-Limit  The maximum request limit
   • 5.當限流達到上限，可以自定義訊息和方法，返回資訊
   • 6.它是基於 golang.org/x/time/rate 開發
2. java 的 guava 限流
   • ratelimiter
3. 基於訊號量限流
   • https://github.com/golang/net/blob/master/netutil/listen.go
4. sentinel-go 服務治理軟體以及sentinel
   • https://github.com/alibaba/sentinel-golang
   • github.com/alibaba/Sentinel ，java編寫的流控元件，服務治理
5. 還有各種基於 nginx 的限流器，限流軟體-服務閘道器，api gateway等

四、參考

• https://github.com/golang/time
• pkg.go.dev/golang.org/x/time/rate
• https://zhuanlan.zhihu.com/p/100594314
• https://segmentfault.com/a/1190000023033365
• https://www.cyhone.com/articles/usage-of-golang-rate/
• https://www.cyhone.com/articles/analysis-of-uber-go-ratelimit
• uber ratelimit vs go time/rate demo
• uber-go ratelimit