Explicación detallada del uso del limitador de corriente oficial de Go

¡Acostúmbrate a escribir juntos! Este es el sexto día de mi participación en el "Nuggets Daily New Plan · April Update Challenge", haz clic para ver los detalles del evento .

El limitador de corriente es un componente muy importante para mejorar la estabilidad del servicio.Se puede utilizar para limitar la tasa de solicitudes y proteger el servicio de la sobrecarga del servicio. Hay muchas formas de implementar el limitador de corriente. Los algoritmos comunes de limitación de corriente incluyen ventana fija, ventana deslizante, cubeta con fugas y cubeta con fichas.

En pocas palabras, el balde de fichas es imaginar un balde de un tamaño fijo. El sistema colocará tokens en el balde a una tasa constante, y el balde no se liberará temporalmente cuando esté lleno. Cuando la cantidad de solicitudes es relativamente pequeña, el depósito puede "guardar" algunos tokens primero para lidiar con el tráfico repentino. Si quedan tokens restantes en el depósito, se pueden tomar todo el tiempo. Si no queda ningún Token, debe esperar hasta que el Token se coloque en el depósito.

Después de que algunos estudiantes entendieron el principio del balde de fichas, realmente quieren implementar un limitador de corriente y aplicarlo a sus propios proyectos, em... ¿Cómo debería decir? aplicación En proyectos comerciales, no tiene que construir las ruedas usted mismo. ¡Golang ya ha construido las ruedas para nosotros...~!

La biblioteca de extensión proporcionada oficialmente por Golang viene con la implementación del algoritmo de limitación actual, es decir, golang.org/x/time/rate. El limitador actual también se implementa en función de Token Bucket.

La estructura interna del limitador de corriente.

time/rateEl tipo del paquete Limiterdefine el limitador de corriente, y todas las funciones de limitación de corriente se implementan en función Limiterdel tipo, y su estructura interna es la siguiente:

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

Sus campos principales son:

• limit: limitEl campo indica la tasa a la que se ponen los Tokens en el bucket, su tipo es Limit, que es el alias de tipo de int64. Al configurar limit, puede usar números para especificar cuántos tokens se colocan en el depósito por segundo, y también puede especificar el intervalo de tiempo para liberar tokens en el depósito . De hecho, después de especificar la cantidad de tokens por segundo, puede calcular el tiempo para liberar cada Token intervalo.

• ráfaga: El tamaño del depósito de fichas.

• tokens: Fichas en el cubo.

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

总结

Hoy resumimos el uso del limitador de corriente oficial de Golang, que es un limitador de corriente implementado por el cálculo del depósito de fichas. Entre ellos, se suelen utilizar con más frecuencia Wait/WaitN y Allow/AllowN . El primero es para hacer que el programa espere un nuevo Token en el cubo si el Token en el cubo es insuficiente al consumir Tokens (es mejor configurar el tiempo de espera). time) Este último es para optar por descartar directamente la solicitud cuando el Token en el cubo es insuficiente.

Además de la implementación del limitador de corriente proporcionado oficialmente por Golang, el limitador de corriente de código abierto de Uber uber-go/ratelimittambién es una buena opción. A diferencia del limitador de corriente oficial de Golang, el limitador de corriente de Uber se implementa a través del algoritmo de cubeta con fugas, pero no es adecuado para los tradicionales. Se ha mejorado el algoritmo del balde con fugas y los estudiantes interesados ​​pueden experimentarlo por sí mismos.