Penjelasan terperinci tentang penggunaan pengehad semasa rasmi Golang

Penghad semasa adalah komponen yang sangat penting untuk meningkatkan kestabilan perkhidmatan Ia boleh digunakan untuk mengehadkan kadar permintaan dan melindungi perkhidmatan untuk mengelakkan lebihan perkhidmatan. Terdapat banyak cara untuk melaksanakan algoritma pengehad semasa yang biasa termasuk tetingkap tetap, tetingkap gelongsor, baldi bocor dan baldi token artikel saya sebelum ini "Senario Aplikasi dan Prinsip Pelaksanaan Algoritma Pengehadan Semasa yang Biasa Digunakan". ciri-ciri dan senario aplikasi kaedah mengehadkan semasa ini Baldi token juga boleh mengendalikan letusan lalu lintas tertentu sambil mengehadkan arus, yang serupa dengan fakta bahawa aplikasi Internet terdedah kepada puncak trafik secara tiba-tiba kerana peristiwa panas.

Secara ringkasnya, baldi token adalah baldi bersaiz tetap. Apabila terdapat sedikit permintaan, baldi boleh "menyimpan" beberapa token terlebih dahulu untuk mengatasi trafik yang tiba-tiba Jika terdapat baki token dalam baldi, ia boleh ditarik balik secara berterusan. Jika tiada token yang tinggal, anda perlu menunggu sehingga token diletakkan di dalam baldi.

Untuk penjelasan yang lebih terperinci tentang pengehadan arus baldi token, sila rujuk artikel: Senario aplikasi dan prinsip pelaksanaan algoritma pengehadan semasa yang biasa digunakan

Sesetengah pelajar benar-benar ingin melaksanakannya sendiri setelah memahami prinsip baldi token Gunakan pengehad semasa untuk projek anda sendiri, em... Bagaimana saya boleh menyatakannya, membina roda sememangnya membantu untuk meningkatkan tahap anda sendiri, tetapi jika anda menggunakannya untuk projek komersial, anda sebenarnya tidak perlu membina roda sendiri pegawai Golang sudah buat untuk kita Roda terbina...~!

Pustaka sambungan yang disediakan secara rasmi oleh Golang dilengkapi dengan pelaksanaan algoritma pengehadan semasa, iaitu golang.org/x/time/rate. Pengehad semasa ini juga dilaksanakan berdasarkan Token Bucket. golang.org/x/time/rate。该限流器也是基于 Token Bucket(令牌桶) 实现的。

限流器的内部结构

time/rate包的Limiter类型对限流器进行了定义，所有限流功能都是通过基于Limiter

Struktur dalaman pengehad semasa

masa/kadar pakejLimiter type mentakrifkan pengehad semasa. Semua fungsi pengehad semasa adalah berdasarkan Limiter jenis pelaksanaan, struktur dalamannya adalah seperti berikut: 🎜

type Limiter struct {
 mu     sync.Mutex
 limit  Limit
 burst  int // 令牌桶的大小
 tokens float64
 last time.Time // 上次更新tokens的时间
 lastEvent time.Time // 上次发生限速器事件的时间（通过或者限制都是限速器事件）
}

🎜Fungsi medan utamanya ialah: 🎜

• limit：limit字段表示往桶里放Token的速率，它的类型是Limit，是int64的类型别名。设置limit时既可以用数字指定每秒向桶中放多少个Token，也可以指定向桶中放Token的时间间隔，其实指定了每秒放Token的个数后就能计算出放每个Token的时间间隔了。
• burst: 令牌桶的大小。
• tokens: 桶中的令牌。
• last: 上次往桶中放 Token 的时间。
• lastEvent：上次发生限速器事件的时间（通过或者限制都是限速器事件）

可以看到在 timer/rate 的限流器实现中，并没有单独维护一个 Timer 和队列去真的每隔一段时间向桶中放令牌，而是仅仅通过计数的方式表示桶中剩余的令牌。每次消费取 Token 之前会先根据上次更新令牌数的时间差更新桶中Token数。

大概了解了time/rate限流器的内部实现后，下面的内容我们会集中介绍下该组件的具体使用方法：

构造限流器

我们可以使用以下方法构造一个限流器对象：

limiter := rate.NewLimiter(10, 100);

这里有两个参数：

1. 第一个参数是 r Limit，设置的是限流器Limiter的limit字段，代表每秒可以向 Token 桶中产生多少 token。Limit 实际上是 float64 的别名。
2. 第二个参数是 b int，b 代表 Token 桶的容量大小，也就是设置的限流器 Limiter 的burst字段。

那么，对于以上例子来说，其构造出的限流器的令牌桶大小为 100, 以每秒 10 个 Token 的速率向桶中放置 Token。

除了给r Limit参数直接指定每秒产生的 Token 个数外，还可以用 Every 方法来指定向桶中放置 Token 的间隔，例如：

limit := rate.Every(100 * time.Millisecond);
limiter := rate.NewLimiter(limit, 100);

以上就表示每 100ms 往桶中放一个 Token。本质上也是一秒钟往桶里放 10 个。

使用限流器

Limiter 提供了三类方法供程序消费 Token，可以每次消费一个 Token，也可以一次性消费多个 Token。每种方法代表了当 Token 不足时，各自不同的对应手段，可以阻塞等待桶中Token补充，也可以直接返回取Token失败。

Wait/WaitN

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

Wait 实际上就是 WaitN(ctx,1)。

当使用 Wait 方法消费 Token 时，如果此时桶内 Token 数组不足 (小于 N)，那么 Wait 方法将会阻塞一段时间，直至 Token 满足条件。如果充足则直接返回。

这里可以看到，Wait 方法有一个 context 参数。我们可以设置 context 的 Deadline 或者 Timeout，来决定此次 Wait 的最长时间。

// 一直等到获取到桶中的令牌
err := limiter.Wait(context.Background())
if err != nil {
 fmt.Println("Error: ", err)
}

// 设置一秒的等待超时时间
ctx, _ := context.WithTimeout(context.Background(), time.Second * 1)
err := limiter.Wait(ctx)
if err != nil {
 fmt.Println("Error: ", err)
}

Allow/AllowN

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

Allow 实际上就是对 AllowN(time.Now(),1) 进行简化的函数。

AllowN 方法表示，截止到某一时刻，目前桶中数目是否至少为 n 个，满足则返回 true，同时从桶中消费 n 个 token。反之不消费桶中的Token，返回false。

对应线上的使用场景是，如果请求速率超过限制，就直接丢弃超频后的请求。

if limiter.AllowN(time.Now(), 2) {
    fmt.Println("event allowed")
} else {
    fmt.Println("event not allowed")
}

Reserve/ReserveN

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

Reserve 相当于 ReserveN(time.Now(), 1)。

ReserveN 的用法就相对来说复杂一些，当调用完成后，无论 Token 是否充足，都会返回一个 *Reservation 对象。你可以调用该对象的Delay()方法，该方法返回的参数类型为time.Duration，反映了需要等待的时间，必须等到等待时间之后，才能进行接下来的工作。如果不想等待，可以调用Cancel()方法，该方法会将 Token 归还。

举一个简单的例子，我们可以这么使用 Reserve 方法。

r := limiter.Reserve()
f !r.OK() {
    // Not allowed to act! Did you remember to set lim.burst to be > 0 ?
    return
}
time.Sleep(r.Delay())
Act() // 执行相关逻辑

动态调整速率和桶大小

Limiter 支持创建后动态调整速率和桶大小：

1. SetLimit(Limit) 改变放入 Token 的速率
2. SetBurst(int) 改变 Token 桶大小

有了这两个方法，可以根据现有环境和条件以及我们的需求，动态地改变 Token 桶大小和速率。

总结

今天我们总结了 Golang 官方限流器的使用方法，它是一种令牌桶算实现的限流器。其中 Wait/WaitN，Allow/AllowN 这两组方法在平时用的比较多，前者是消费Token时如果桶中Token不足可以让程序等待桶中新Token的放入（最好设置上等待时长）后者则是在桶中的Token不足时选择直接丢弃请求。

Selain pelaksanaan pengehad semasa yang disediakan secara rasmi oleh Golang, pengehad semasa sumber terbuka Uberuber-go/ratelimit juga merupakan pilihan yang baik Berbeza daripada pengehad semasa rasmi Golang, pengehad semasa Uber dilaksanakan melalui algoritma baldi bocor, tetapi untuk algoritma baldi bocor tradisional. telah dipertingkatkan, dan pelajar yang berminat boleh mengalaminya sendiri.

Atas ialah kandungan terperinci Penjelasan terperinci tentang penggunaan pengehad semasa rasmi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!