La minuterie Golang implémente la limitation de courant

Dans le développement quotidien, nous sommes souvent confrontés à des scénarios à forte concurrence, et une limitation stricte du courant est particulièrement importante en ce moment. Dans Golang, une manière courante d'implémenter la limitation de courant consiste à utiliser une minuterie (Timer) pour limiter le nombre de requêtes simultanées en contrôlant l'heure de déclenchement de la minuterie. Cet article explique comment utiliser la minuterie de Golang pour implémenter la limitation de courant.

1. Qu'est-ce qu'une minuterie ?

Dans Golang, Timer est un minuteur au niveau du système. Vous pouvez créer un minuteur pour déclencher régulièrement des tâches ou des événements. Lors de la création d'une minuterie, vous devez spécifier un intervalle de temps et vous pouvez utiliser la méthode Reset pour réinitialiser ou arrêter la minuterie.

L'idée de base de l'utilisation d'une minuterie pour mettre en œuvre une limitation de courant est la suivante : définir un intervalle de temps, par exemple 1 seconde. Chaque fois qu'une demande arrive, nous réinitialisons la minuterie si le nombre de demandes arrivant dans un délai d'une seconde dépasse le seuil de réglage. , les demandes seront rejetées.

2. Le processus d'utilisation des minuteries pour mettre en œuvre la limitation de courant

Le processus d'utilisation des minuteries pour mettre en œuvre la limitation de courant est le suivant :

1. Initialisez les compteurs et les minuteries.
2. Chaque fois qu'une demande est reçue, augmentez la valeur du compteur et réinitialisez la minuterie.
3. Lorsque l'intervalle de temps arrive, déterminez si la valeur du compteur dépasse la valeur limite. Si elle dépasse, rejetez la demande, sinon effacez le compteur et attendez la prochaine demande.

3. Exemple de code d'implémentation

Dans Golang, le package time de la bibliothèque standard fournit le type Timer et le type Ticker, qui peuvent être utilisés pour créer des minuteries. Voici un exemple de code qui utilise Timer pour implémenter la limitation de courant :

package main

import (
    "fmt"
    "time"
)

func main() {
    maxRequests := 100 //最多请求量
    interval := 1 * time.Second //间隔时间
    timer := time.NewTimer(interval)
    counter := 0 //请求计数器

    for {
        select {
        case <-timer.C: // 定时器到期
            fmt.Println("time up")
            if counter > maxRequests { // 如果请求数超出限制
                fmt.Printf("too many requests, counter=%d
", counter)
            } else {
                fmt.Printf("counter=%d
", counter)
            }
            counter = 0 // 重置计数器
            timer.Reset(interval) // 重置定时器
        default:
            time.Sleep(time.Millisecond * 100) // 模拟处理请求的耗时
            counter++ // 计数器加1
        }
    }
}

Analyse du code :

Cet exemple de code définit un contrôleur de limitation de courant avec un nombre maximum de requêtes de 100 et un intervalle de 1 seconde. Dans la boucle principale, surveillez l'événement d'expiration du minuteur via l'instruction select et effectuez un traitement de limitation de courant lorsque le minuteur expire.

Utilisez time.Sleep dans la branche par défaut pour simuler le temps de consommation de la demande et ajoutez 1 au compteur. Lorsque le minuteur expire, déterminez si la valeur du compteur dépasse le seuil défini. Si c'est le cas, rejetez la demande et affichez un message d'invite indiquant qu'il y a trop de demandes. Sinon, affichez le nombre actuel de demandes, effacez le compteur et réinitialisez-le. la minuterie.

4. Utilisez Ticker pour implémenter la limitation de courant

En plus de Timer, Golang fournit également un type de temps appelé Ticker, qui est similaire au type Timer, mais peut déclencher des événements périodiquement. Ce qui suit est un exemple de code qui utilise également des compteurs et des minuteries pour implémenter la limitation de courant. Cette fois, le type Ticker est utilisé :

package main

import (
    "fmt"
    "time"
)

func main() {
    maxRequests := 100 //最多请求量
    interval := 1 * time.Second //间隔时间
    ticker := time.NewTicker(interval)
    counter := 0 //请求计数器

    for {
        select {
        case <-ticker.C: // 定时器到期
            fmt.Println("time up")
            if counter > maxRequests { // 如果请求数超出限制
                fmt.Printf("too many requests, counter=%d
", counter)
            } else {
                fmt.Printf("counter=%d
", counter)
            }
            counter = 0 // 重置计数器
        default:
            time.Sleep(time.Millisecond * 100) // 模拟处理请求的耗时
            counter++ // 计数器加1
        }
    }
}

La différence avec l'exemple de code implémenté par Timer est que cette fois nous utilisons l'objet timer créé par NewTicker. fonction. Et écoutez l'événement tick du timer dans la boucle principale. Lorsque l'événement tick arrive, le compteur est vérifié et effacé, le temps de traitement de la requête est simulé dans la branche par défaut et la valeur du compteur est incrémentée.

Il convient de noter que lors de l'utilisation de Ticker, la méthode Stop doit être appelée pour arrêter le timer à la fin du programme, sinon le timer fonctionnera toujours en arrière-plan et gaspillera des ressources.

V. Résumé

Cet article explique comment utiliser la minuterie (Timer) et le Ticker de Golang pour implémenter la limitation de courant dans les scénarios à forte concurrence, un contrôle strict de limitation de courant est crucial. L'utilisation de minuteries pour implémenter la limitation de courant est un moyen efficace et fiable et constitue un composant indispensable pour de nombreuses applications Web au niveau de l'entreprise.

Pendant le processus de mise en œuvre, vous devez comprendre le principe de fonctionnement et l'utilisation de la minuterie, et définir raisonnablement des paramètres tels que l'intervalle de temps et le nombre maximum de demandes pour garantir que le contrôle de limitation de courant puisse obtenir l'effet optimal.

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!