Qu’est-ce que le taux de Golang ? Explication détaillée de l'utilisation des tarifs

Le langage Go est un langage de programmation efficace, simultané et au niveau du système. Le package Rate est un package très utile dans le langage Go qui vous permet de contrôler le taux de diverses opérations. Dans cet article, nous présenterons l'utilisation du package Rate pour vous aider à mieux maîtriser son utilisation.

1. Présentation du package Rate

Le package Rate est un package de la bibliothèque standard du langage Go. Il fournit une méthode pour effectuer certaines opérations à un tarif fixe. Par exemple, nous pouvons utiliser ce package pour limiter le taux de requêtes API, contrôler la fréquence à laquelle certaines opérations sont effectuées, etc.

Ce package propose deux méthodes courantes de limitation de débit : limiter la fréquence à laquelle certaines opérations sont effectuées par seconde ou la fréquence à laquelle certaines opérations sont effectuées par unité de temps. Ces deux méthodes de restriction peuvent être librement définies manuellement à l'aide du type time.Duration de la langue go pour répondre à leurs besoins respectifs.

2. Utilisation de base

1. Opérations de base

Le package Rate fournit deux opérations : Allow() et Limit(). La forme de base de l’algorithme du compartiment à jetons est définie dans la méthode Allow(). Autrement dit, combien de jetons se trouvent dans le compartiment de jetons, l'opération définie peut alors être autorisée. Limit() renvoie deux valeurs contenant les jetons utilisés et disponibles.

2. Effectuer certaines opérations à un rythme fixe

Si nous devons effectuer certaines opérations à un rythme fixe pour chaque opération, le package Rate fournit un limiteur : une interface API qui limite les instances qui effectuent des opérations à un certain rythme. Par exemple :

func main() {
    rate := rate.NewLimiter(10, 1)
    for i := 1; i <= 50; i++ {
        if rate.Allow() == false {
            fmt.Println("No allowance for", i)
            continue
        }
        fmt.Println("Hello", i)
    }
}

Dans le code ci-dessus, nous créons un taux d'instance qui effectuera des opérations avec une limite de taux de 10 opérations par seconde. Ensuite, nous bouclons et effectuons l'opération 50 fois. Si l'opération n'est pas autorisée, l'opération en cours est ignorée. Sinon, il exécute et imprime Hello ainsi que le nombre d'opérations.

3. Limiter l'exécution des opérations sur une période de temps

En plus de limiter les opérations à un taux fixe d'opérations par seconde, le package Rate propose également une méthode : limiter le nombre d'opérations sur une période de temps donnée. Par exemple :

func main() {
    limit := rate.NewLimiter(1, 1)
    duration := time.Minute
    operations := 10
    
    timeStart := time.Now()

    for i := 0; i < operations; i++ {
        if err := limit.Wait(ctx); err != nil {
            log.Fatalf("Error waiting on limiter: %v", err)
        }
        // Execute operation
    }

    timeEnd := time.Now()

    elapsedTime := timeEnd.Sub(timeStart)

    fmt.Printf("Executed %v operations in %v", operations, elapsedTime)
}

Dans ce code, nous créons une instance de limite d'opération et limitons le nombre d'opérations à 1 par minute. L'instance d'opération attend un signal indiquant que l'opération peut être effectuée, puis exécute l'opération. Nous pouvons également définir le temps limite sur d'autres valeurs en utilisant la fonction WithTimeout du paramètre ctx.

4. Effectuer des opérations en mode rafale

Lorsque nous devons effectuer des opérations en mode rafale, nous pouvons utiliser une instance Bucket pour le faire. Les instances de bucket sont similaires aux instances Limiter, mais elles ont un seuil de contrôle de rafale plus élevé.

Par exemple :

func main() {
        b := rate.NewBucket(time.Second*1, 50)
        t := time.Now()
        for i := 0; i < 110; i++ {
                t = b.Take(1)
                fmt.Printf("i: %v t: %v\n", i, t.UnixNano())
        }
}

Dans le code ci-dessus, nous créons une instance Bucket qui effectue des opérations avec une limite de débit de 50 opérations par seconde. Ensuite, nous bouclons l'opération 110 fois. Le seuil de contrôle du volume des rafales étant de 50, les 50 premières opérations pourront être exécutées immédiatement. Mais attendez le temps d'exécution des opérations suivantes pour que la fenêtre de rafale ne dépasse pas 50 opérations.

Résumé

Nous maîtrisons l'utilisation de base du package Rate et avons utilisé les exemples ci-dessus pour démontrer comment effectuer des opérations à un rythme fixe, par période de temps et en mode rafale. De plus, le package fournit d'autres méthodes utiles (telles que SetLimit() et LimitAt()) qui peuvent vous aider à mieux contrôler le taux d'opérations. Chérissez la vie et évitez le risque de bannissements fréquents de comptes.

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!