Comment implémenter la limitation de courant dans Golang

La limitation de courant est une stratégie courante pour éviter la surcharge du système. En limitant le taux de requêtes du système, la disponibilité du système peut être garantie et la perte de données causée par des pannes du système peut être évitée. Dans les applications d'ingénierie réelles, une limitation de courant est souvent nécessaire pour garantir la stabilité du système. Cet article expliquera comment utiliser Golang pour implémenter la fonction de limitation de courant.

1. Algorithme de limitation de courant

L'algorithme de limitation de courant fait référence à un algorithme qui contrôle le trafic d'une manière ou d'une autre. Utiliser un algorithme de limitation de courant dans un programme signifie généralement contrôler la vitesse de traitement du programme. Les algorithmes courants de limitation de courant incluent l'algorithme de compartiment à fuite et l'algorithme de compartiment à jetons.

Algorithme de seau qui fuit : l'algorithme de seau qui fuit est un seau qui fuit avec une capacité fixe. De l'eau y est ajoutée à un certain taux. Lorsque l'eau dépasse la capacité du seau, elle déborde. Autrement dit, si l’eau entre plus vite que l’eau ne sort, le seau se remplira et l’eau suivante sera rejetée.

Algorithme de compartiment de jetons : L'algorithme de compartiment de jetons est un compartiment de jetons à capacité fixe. Des jetons y sont ajoutés à un certain rythme. Chaque demande nécessite le traitement d'un jeton. Autrement dit, s’il n’y a pas suffisamment de jetons, la demande sera rejetée.

2. Golang implémente la limitation de courant

Pour implémenter la fonction de limitation de courant dans Golang, vous devez appliquer l'algorithme de limitation de courant aux programmes concurrents. Golang fournit un package de synchronisation intégré qui peut être utilisé pour implémenter la fonction de limitation de courant.

Le code est implémenté comme suit :

package main

import (
    "fmt"
    "sync"
    "time"
)

type Limiter struct {
    sync.Mutex
    limit  int
    count  int
    expire time.Time
}

func NewLimiter(limit int, expire time.Duration) *Limiter {
    return &Limiter{
        limit:  limit,
        count:  0,
        expire: time.Now().Add(expire),
    }
}

func (limit *Limiter) Allow() bool {
    limit.Lock()
    defer limit.Unlock()

    if limit.count < limit.limit {
        limit.count++
        return true
    }

    if time.Now().After(limit.expire) {
        limit.count = 1
        limit.expire = time.Now().Add(time.Second)
        return true
    }

    return false
}

func main() {
    limit := NewLimiter(10, time.Second)
    for i := 0; i < 30; i++ {
        if limit.Allow() {
            fmt.Println(i, "allow")
        } else {
            fmt.Println(i, "deny")
        }
        time.Sleep(100 * time.Millisecond)
    }
}

Dans le code ci-dessus, nous définissons une structure Limiter, qui contient trois champs : limit, count et expire. La limite représente le nombre de requêtes autorisées par seconde, le nombre représente le nombre de requêtes actuellement traitées et expire représente le délai d'expiration.

Créez un objet Limiter via la fonction NewLimiter et transmettez la limite de quantité demandée et le délai d'expiration expire. La méthode Allow est utilisée pour vérifier si la demande est actuellement autorisée à être traitée en fonction de l'heure actuelle et des restrictions de limite et d'expiration, et mettre à jour les champs de nombre et d'expiration.

Dans la fonction principale, nous utilisons une boucle pour tester si Limiter peut limiter le nombre de requêtes traitées par seconde et utilisons la fonction time.Sleep pour faire une pause de 100 millisecondes.

3. Résumé

La fonction de limitation de courant est une exigence très courante dans le développement de programmes. En limitant le taux de requêtes, vous pouvez protéger la sécurité et la stabilité de votre programme. Cet article présente comment implémenter la fonction de limitation de courant dans Golang. En utilisant le package de synchronisation et l'objet Limiter, nous pouvons facilement implémenter le contrôle de flux pour les programmes à haute concurrence.

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!