Explication détaillée de l'utilisation du limiteur de courant officiel Go

Prenez l'habitude d'écrire ensemble ! C'est le sixième jour de ma participation au "Nuggets Daily New Plan · April Update Challenge", cliquez pour voir les détails de l'événement .

Le limiteur de courant est un composant très important pour améliorer la stabilité du service, il peut être utilisé pour limiter le taux de requête et protéger le service d'une surcharge du service. Il existe de nombreuses façons d'implémenter le limiteur de courant. Les algorithmes courants de limitation de courant incluent la fenêtre fixe, la fenêtre glissante, le seau qui fuit et le seau à jetons.

Pour faire simple, le seau à jetons consiste à imaginer un seau d'une taille fixe. Le système mettra des jetons dans le seau à un rythme constant, et le seau ne sera pas libéré temporairement lorsque le seau sera plein. Lorsque le nombre de requêtes est relativement faible, le bucket peut d'abord "enregistrer" quelques jetons pour faire face à un trafic soudain. S'il reste des jetons dans le bucket, il peut être utilisé tout le temps. S'il ne reste plus de jeton, vous devez attendre que le jeton soit placé dans le seau.

Après que certains étudiants aient compris le principe du seau à jetons, ils veulent vraiment implémenter un limiteur de courant et l'appliquer à leurs propres projets, em... Comment dire, construire une roue est en effet propice à améliorer son propre niveau, mais si le application Dans les projets commerciaux, vous n'avez pas besoin de construire les roues vous-même. Golang a déjà construit les roues pour nous...~ !

La bibliothèque d'extensions officiellement fournie par Golang est livrée avec l'implémentation de l'algorithme de limitation actuel, c'est-à-dire golang.org/x/time/rate. Le limiteur de courant est également implémenté sur la base de Token Bucket.

La structure interne du limiteur de courant

time/rateLe type de package Limiterdéfinit le limiteur de courant, et toutes les fonctions de limitation de courant sont implémentées en fonction Limiterdu type, et sa structure interne est la suivante :

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

Ses principaux domaines sont :

• limit : limitle champ indique la vitesse à laquelle les jetons sont placés dans le compartiment. Son type est Limit, qui est l'alias de type de int64. Lorsque vous définissez limit, vous pouvez utiliser des nombres pour spécifier le nombre de jetons placés dans le compartiment par seconde, et vous pouvez également spécifier l'intervalle de temps pour libérer les jetons dans le compartiment . En fait, après avoir spécifié le nombre de jetons par seconde, vous pouvez calculer le temps de libération de chaque Token.

• burst : la taille du seau de jetons.

• jetons : jetons dans le seau.

• 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 桶大小和速率。

总结

Aujourd'hui, nous résumons l'utilisation du limiteur de courant officiel de Golang, qui est un limiteur de courant mis en œuvre par le calcul du seau à jetons. Parmi eux, Wait/WaitN et Allow/AllowN sont généralement utilisés plus souvent. Le premier consiste à faire attendre le programme pour un nouveau Token dans le bucket si le Token dans le bucket est insuffisant lors de la consommation de Tokens (il est préférable de définir l'attente time) Ce dernier consiste à choisir de rejeter directement la requête lorsque le Token dans le bucket est insuffisant.

En plus de la mise en œuvre du limiteur de courant officiellement fourni par Golang, le limiteur de courant open source d'Uber est uber-go/ratelimitégalement un bon choix.Contrairement au limiteur de courant officiel de Golang, le limiteur de courant d'Uber est mis en œuvre via l'algorithme de seau qui fuit, mais il ne convient pas aux traditionnels L'algorithme du seau qui fuit a été amélioré et les étudiants intéressés peuvent en faire l'expérience par eux-mêmes.