Comment annuler l'exécution d'un Go Goroutine après un timeout ?

Annulation de l'exécution de Goroutine en cas d'expiration du délai

Dans les routines Go, il peut être nécessaire de mettre fin aux opérations au-delà d'un seuil de temps spécifique. Cela peut présenter des défis, car Go exécute généralement les goroutines de manière asynchrone sans contrôle direct sur leur exécution. Un scénario courant se produit lors de l'utilisation du framework iris, dans lequel vous pouvez rencontrer des situations dans lesquelles une goroutine continue de s'exécuter même après un délai d'attente.

Considérez l'extrait de code suivant :

package main

import (
    "fmt"
    "time"
)

func main() {
    Res := make(chan Response, 1)

    go func() {
        time.Sleep(10 * time.Second)
        fmt.Println("test")
        Res <- Response{data: "data", status: true}
    }()

    select {
    case <-Res:
        fmt.Println("Read from ch")
        res := <-Res
        fmt.Println(res.data, res.status)
    case <-time.After(50 * time.Millisecond):
        fmt.Println("Timed out")
    }
}

type Response struct {
    data   interface{}
    status bool
}

Comme illustré dans l'exemple, une goroutine est lancée pour imprimer le test après un délai de 10 secondes. Un canal (Res) est utilisé pour faciliter la communication entre la goroutine et la goroutine principale. Une instruction select est utilisée pour attendre soit une réponse de la goroutine, soit un délai d'attente de 50 millisecondes.

Cependant, le comportement attendu est que la goroutine doit être terminée dès que le délai d'attente se produit. Au lieu de cela, la sortie montre que le test est toujours imprimé même si le délai d'attente a expiré.

Cela se produit car il n'existe pas de méthode simple dans Go pour interrompre de force l'exécution d'une goroutine en cours d'exécution. Go fonctionne sur un modèle de concurrence fork-join, dans lequel une nouvelle goroutine est créée en tant que thread d'exécution distinct. Une fois créées, la planification et la gestion des goroutines deviennent une partie de la responsabilité du runtime Go.

Pour résoudre ce problème, il est recommandé d'adopter des techniques de synchronisation qui permettent un contrôle plus granulaire sur le comportement des goroutines.

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!