Comment implémenter un mécanisme de délai d'attente à l'aide de Golang

Lors de l'écriture d'applications réseau, vous rencontrez souvent des situations dans lesquelles vous devez définir un mécanisme de délai d'attente. Le mécanisme de délai d'attente fait référence à l'attente qu'une opération soit terminée dans un certain laps de temps, comme l'attente d'une réponse à une demande à distance ou l'attente qu'un événement se produise. En tant que langage efficace, le langage Go fournit également une implémentation de mécanisme de délai d'attente relativement simple et facile à utiliser. Cet article explique comment utiliser Golang pour implémenter le mécanisme de délai d'attente.

Quel est le mécanisme de délai d'attente ?

Avant de comprendre le mécanisme de délai d'attente, examinons d'abord ce que sont les opérations de blocage. Une opération bloquante signifie qu’une opération est bloquée pour une raison quelconque et ne peut pas continuer. Par exemple, attendre une réponse à une requête réseau, attendre une réponse d'un périphérique d'E/S, etc.

Le mécanisme de délai d'attente consiste à spécifier une période de temps lors de l'exécution d'une opération de blocage. Si l'opération n'est pas terminée dans le délai spécifié, l'opération sera activement terminée et un message d'erreur sera renvoyé. L'avantage est que dans certains cas, nous devons éviter de bloquer les opérations trop longtemps, provoquant des problèmes tels que le blocage de l'interface utilisateur ou le fait que le client ne reçoive pas de réponse pendant une longue période.

Mise en œuvre du mécanisme de délai d'attente de Golang

Dans Golang, nous pouvons implémenter le mécanisme de délai d'attente via Goroutines et Channels. Ces deux méthodes seront présentées ci-dessous.

Goroutine implémente le délai d'attente

Goroutine en langage Go est équivalent à un thread léger qui peut coordonner des tâches simultanées. Lorsqu'un mécanisme de délai d'attente est nécessaire, nous pouvons utiliser Goroutine pour l'implémenter.

Ce qui suit est un exemple de code qui utilise Goroutine pour implémenter le mécanisme de délai d'attente :

package main

import (
    "fmt"
    "time"
)

func main() {
    data := make(chan int)
    done := make(chan struct{})
    go func() {
        for {
            select {
            case d := <-data:
                fmt.Println("Received data:", d)
            case <-time.After(time.Second * 2):
            fmt.Println("Timeout")
            close(done)
            }
        }
    }()
    for i := 0; i < 5; i++ {
        data <- i
        time.Sleep(time.Second * 1)
    }
    <-done
    fmt.Println("Done")
}

Le code ci-dessus utilise Goroutine pour implémenter le mécanisme de délai d'attente : lors de la réception de données (d := <-data), imprimez les données reçues. Lorsqu'aucune donnée n'est reçue pendant plus de 2 secondes, les informations de délai d'attente sont imprimées et le signal terminé est désactivé. Dans le programme principal, envoyez des données au pipeline de données (toutes les secondes) et utilisez Sleep pour simuler un long temps de blocage.

Lorsque le programme est en cours d'exécution, surveillez entre les données et la minuterie via l'instruction select. Lorsque les données sont reçues, la sélection apparaîtra lorsque le délai expire, les informations seront imprimées et terminées. Après avoir reçu 5 éléments de données, le programme ferme done et imprime Done pour indiquer la fin du mécanisme de délai d'attente.

Channel implémente un délai d'attente

Channel en langage Go est une méthode de communication qui peut coordonner des tâches simultanées. Dans les opérations qui nécessitent un délai d'attente, nous pouvons également utiliser Channel pour l'implémenter.

Ce qui suit est un exemple de code qui utilise Channel pour implémenter le mécanisme de délai d'attente :

package main

import (
    "fmt"
    "time"
)

func main() {
    data := make(chan int, 1)
    timeOut := make(chan bool, 1)

    go func() {
        time.Sleep(time.Second * 2)
        timeOut <- true
    }()

    select {
        case d := <-data:
            fmt.Println(d) // 接收成功
        case <-timeOut:
            fmt.Println("Receive timeout")
    }
}

Le code ci-dessus utilise Channel pour implémenter le mécanisme de délai d'attente, envoie des données au pipeline de données (la capacité est de 1), puis écoute dans l'instruction select . Après lecture des données dans le canal, l'opération d'impression des données peut être déclenchée. Et s'il expire, il ne bloquera plus et n'attendra plus, mais déclenchera la branche timeout.

Étant donné que la capacité du timeOut et du canal de données est toutes deux égale à 1, l'écriture des données sera bloquée jusqu'à ce qu'un lecteur lise les données ou expire. TimeOut écrit les données après deux secondes d'expiration, déclenchant une opération de lecture.

La méthode d'implémentation du mécanisme de délai d'attente via Channel est plus simple que Goroutine, mais il convient de noter que la taille du tampon de données doit être limitée à 1, sinon l'effet de délai d'attente attendu ne sera pas obtenu.

Résumé

Cet article présente deux façons d'implémenter le mécanisme de délai d'attente à l'aide de Golang : en utilisant Goroutine et Channel. Les deux méthodes peuvent bien implémenter le mécanisme de délai d'attente, la méthode à choisir dépend des besoins réels. Lors de l'utilisation du mécanisme de délai d'attente, nous devons faire différents choix en fonction de différents scénarios pour améliorer la robustesse et la sécurité de l'application.

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!