Comment utiliser le contexte pour implémenter le contrôle de concurrence des requêtes dans Go

En tant que langage de programmation haute performance, le langage Go a toujours été exceptionnel dans ses capacités de programmation simultanée. Afin de mieux gérer et contrôler les requêtes simultanées, en langage Go, nous pouvons utiliser le contexte pour implémenter le contrôle de simultanéité des requêtes. Cet article présentera comment utiliser le contexte pour implémenter le contrôle de concurrence des requêtes dans le langage Go et le démontrera à travers des exemples de code.

Introduction au Context

Dans le langage Go, le package context fournit un moyen de gérer les demandes de collision. Il peut transmettre des données à l'échelle de la requête entre les goroutines, y compris les délais, les délais d'attente, les signaux d'annulation, etc. En utilisant le contexte, nous pouvons mieux gérer et contrôler les demandes simultanées.

Étapes pour utiliser le contexte pour implémenter le contrôle de simultanéité des requêtes

Voici les étapes pour utiliser le contexte pour implémenter le contrôle de simultanéité des requêtes :

1. Créer un contexte racine : Tout d'abord, nous devons créer un contexte racine. Le contexte racine est le contexte parent de tous les contextes enfants. Nous pouvons utiliser context.TODO() ou context.Background() pour créer un contexte racine vide. context.TODO()或context.Background()来创建一个空的根context。

ctx := context.TODO()

2. 创建子context：接下来，我们可以使用context.WithXXX()函数创建一个子context。这个函数接收一个父context作为参数，并返回一个新的子context。

childCtx := context.WithTimeout(ctx, time.Second*10)

在上述代码中，我们使用context.WithTimeout()函数创建了一个超时为10秒的子context。

3. 处理请求：在处理具体的请求时，我们可以使用context.Context类型的参数接收传递过来的context。在处理请求的过程中，我们可以使用context.Context的方法来获取context的相关信息。

func HandleRequest(ctx context.Context) {
    // 处理请求
}

4. 控制并发：在进行并发请求时，我们可以使用context.Context的Done()方法来判断请求是否被取消或超时。当调用Done()方法时，它会返回一个只读的Channel。如果请求被取消或超时，Done()方法会关闭这个Channel。

go func() {
    for {
        select {
        case <-ctx.Done():
            return
        default:
            // 发起请求
            HandleRequest(ctx)
        }
    }
}()

在上述代码中，我们使用for循环和select语句来监听context的Done()方法。当Done()方法返回时，我们就知道请求已经被取消或超时，可以退出循环。

5. 取消请求：在某些情况下，我们希望取消正在处理的请求。这时，我们可以调用context.CancelFunc类型的cancel()

cancel()

Créer un sous-contexte : Ensuite, nous pouvons utiliser la fonction context.WithXXX() pour créer un sous-contexte. Cette fonction reçoit un contexte parent en paramètre et renvoie un nouveau contexte enfant.

package main

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

func Worker(ctx context.Context, wg *sync.WaitGroup) {
    defer wg.Done()
 
    for {
        select {
        case <-ctx.Done():
            // 请求已被取消或超时
            return
        default:
            // 处理请求
            fmt.Println("Handling request...")
            time.Sleep(time.Second * 1)
        }
    }
}

func main() {
    ctx := context.TODO()
    childCtx, cancel := context.WithTimeout(ctx, time.Second*5)
    defer cancel()

    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go Worker(childCtx, &wg)
    }

    wg.Wait()
    fmt.Println("All requests processed")
}

Dans le code ci-dessus, nous utilisons la fonction context.WithTimeout() pour créer un sous-contexte avec un délai d'attente de 10 secondes.

Traitement des requêtes : lors du traitement de requêtes spécifiques, nous pouvons utiliser des paramètres de type context.Context pour recevoir le contexte transmis. Pendant le processus de traitement de la demande, nous pouvons utiliser la méthode context.Context pour obtenir des informations liées au contexte.

rrreee

Contrôler la concurrence : lors des requêtes simultanées, nous pouvons utiliser la méthode Done() de context.Context pour déterminer si la requête a été annulée ou expirée. . Lorsque la méthode Done() est appelée, elle renvoie un Channel en lecture seule. Si la demande est annulée ou expire, la méthode Done() fermera le canal.
rrreee

Dans le code ci-dessus, nous utilisons une boucle for et une instruction select pour écouter la méthode de contexte Done(). Lorsque la méthode Done() revient, nous savons que la requête a été annulée ou a expiré, et nous pouvons quitter la boucle.

🎜Annuler la demande : dans certains cas, nous souhaitons annuler une demande en cours de traitement. A ce moment, nous pouvons appeler la méthode cancel() de type context.CancelFunc pour annuler la requête. 🎜🎜rrreee🎜Dans le code ci-dessus, nous appelons la méthode Cancel() pour annuler la requête. 🎜🎜Exemple de code🎜🎜Ce qui suit est un exemple de code simple qui montre comment utiliser le contexte pour implémenter le contrôle de simultanéité des requêtes. 🎜rrreee🎜Dans le code ci-dessus, nous créons un contexte racine et un contexte enfant avec un timeout de 5 secondes. Ensuite, nous avons créé 5 goroutines pour gérer les requêtes. Pendant le processus de traitement de la demande, nous utilisons la méthode Done() du contexte pour déterminer si la demande a été annulée ou a expiré. Enfin, nous utilisons sync.WaitGroup pour attendre que toutes les demandes soient traitées. 🎜🎜Résumé🎜🎜En utilisant le contexte, nous pouvons mieux gérer et contrôler les demandes simultanées. Cet article présente les étapes d'utilisation du contexte pour implémenter le contrôle de concurrence des requêtes et le démontre à l'aide d'un exemple de code. Je pense que les lecteurs peuvent mieux comprendre et appliquer le contexte pour obtenir un contrôle de simultanéité des demandes grâce à l'introduction et à l'exemple de code de cet article. 🎜

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!