Comment limiter les flux en golang ? Explication détaillée de l'algorithme

Avec le développement continu de la technologie Internet, la demande de concurrence élevée et de trafic important devient de plus en plus courante, ce qui rend de plus en plus importante l'importance de la technologie de limitation actuelle. En tant que langage rapide et efficace, Golang ne peut ignorer son application dans la limitation de courant. Voyons donc spécifiquement comment le golang limite le flux de courant.

1. Algorithme d'entonnoir

L'algorithme d'entonnoir est un algorithme de limitation de courant couramment utilisé. Son idée principale est de maintenir un entonnoir avec une capacité fixe, puis d'ajouter de l'eau dans l'entonnoir à un certain rythme. capacité, ce qui suit L'eau débordera et pour les demandes entrant dans l'entonnoir, l'eau dans l'entonnoir doit être consommée. S'il n'y a pas suffisamment d'eau dans l'entonnoir, cela signifie que la demande ne peut pas être traitée à ce moment.

Dans Golang, vous pouvez utiliser le package "rate" pour implémenter l'algorithme d'entonnoir pour la limitation de courant, comme le code suivant :

import (
     "golang.org/x/time/rate"
     "net/http"
)

// 创建一个每秒钟只允许1个请求的漏斗
r := rate.NewLimiter(1, 1)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
     if r.Method != "GET" {
          http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
          return
     }
     if !r.Limiter.CanAllow() {
          http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
          return
     }
     // 处理业务逻辑
})

2. Algorithme de compartiment à jetons

L'algorithme de compartiment à jetons est également un algorithme de limitation de courant courant, son cœur L'idée est de maintenir un compartiment à capacité fixe et de mettre continuellement des jetons dans le compartiment à un certain rythme. Pour les demandes entrant dans le compartiment, les jetons dans le compartiment doivent être consommés. signifie que la demande ne peut pas être traitée pour le moment.

Dans Golang, vous pouvez utiliser le package "golang.org/x/time/rate" pour implémenter l'algorithme de compartiment de jetons pour la limitation de courant, comme le code suivant :

import (
     "golang.org/x/time/rate"
     "net/http"
)

// 创建一个每秒钟只允许1个请求的令牌桶
r := rate.NewLimiter(1, 1)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
     if r.Method != "GET" {
          http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
          return
     }
     if !r.Wait(r.Context()) {
          http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
          return
     }
     // 处理业务逻辑
})

3. L'algorithme est également un L'idée principale de l'algorithme de limitation de courant couramment utilisé est de diviser chaque seconde en plusieurs périodes de temps de taille fixe. Dans chaque période, un compteur de taille fixe est maintenu. Chaque fois qu'une demande est saisie, la valeur correspondante. le temps est Le compteur de segments est incrémenté de un, et si le nombre de requêtes qui entrent dans le compteur atteint la limite supérieure, la requête ne peut pas être traitée.

Dans Golang, vous pouvez utiliser le package "github.com/uber-go/ratelimit" pour implémenter l'algorithme de fenêtre glissante pour la limitation de courant, comme le code suivant :

import (
     "github.com/uber-go/ratelimit"
     "net/http"
)

// 创建一个每秒最多只允许1个请求的滑动窗口
rl := ratelimit.New(10) // 表示在一个时间段内最多允许处理10个请求
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
     if r.Method != "GET" {
          http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
          return
     }
     if !rl.TakeAvailable(1) { // 表示当前请求需要消耗1个计数
          http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
          return
     }
     // 处理业务逻辑
})

Comparaison des algorithmes de compartiment à jetons et de compartiment à fuite.

order Bien que les algorithmes de compartiment de carte et d'entonnoir puissent être utilisés pour limiter le courant, ils sont toujours différents en termes de scénarios d'application, de complexité de l'algorithme, de difficulté de mise en œuvre et d'effets. Plus précisément :

Scénarios d'application : l'algorithme du token bucket est plus adapté pour limiter le trafic moyen et traiter les requêtes à une vitesse constante, tandis que l'algorithme de l'entonnoir est plus adapté pour limiter le trafic de pointe afin d'éviter que le système ne soit submergé par les requêtes dans un temps record. instantané.

• Complexité de l'algorithme : l'algorithme de l'entonnoir a une faible complexité et n'a besoin que de maintenir un compteur de type int et un horodatage ; tandis que l'algorithme du compartiment à jetons doit maintenir la capacité du compartiment à jetons, la vitesse de placement des jetons, etc. De nombreux paramètres.
• Difficulté de mise en œuvre : la mise en œuvre de l'algorithme d'entonnoir est relativement simple. Vous pouvez utiliser une boucle for pour simuler le processus d'ajout d'eau et de consommation d'eau, tandis que l'algorithme du compartiment à jetons doit prendre en compte la sécurité multithread, l'expiration du jeton et plus de détails ; .
• En général, différents algorithmes de limitation de courant ont leurs scénarios d'application spécifiques, leurs avantages et leurs inconvénients, et vous pouvez choisir l'algorithme approprié pour la limitation de courant en fonction des besoins réels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!