Comment arrêter gracieusement une exécution de Goroutine en cas d'expiration dans le framework Iris ?

Arrêter l'exécution de Goroutines en cas d'expiration du délai à l'aide d'Iris Framework

Lorsque vous travaillez avec des goroutines, il est souvent nécessaire d'arrêter leur exécution si elles dépassent un certain délai. Cependant, un problème fréquemment rencontré est que les goroutines continuent de s'exécuter même après un délai d'attente.

Pour tenter de résoudre ce problème, l'extrait de code suivant est utilisé :

import (
    "fmt"
    "time"

    "github.com/kataras/iris/v12"
)

type Response struct {
    data   interface{}
    status bool
}

func (s *CicService) Find() (interface{}, bool) {

    ch := make(chan Response, 1)

    go func() {
      time.Sleep(10 * time.Second)

      fmt.Println("test")
      fmt.Println("test1")

      ch <- Response{data: "data", status: true}
    }()

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

}

Ceci le code utilise un canal mis en mémoire tampon et une instruction select pour tenter de mettre fin à une goroutine si un délai d'attente de 50 millisecondes s'écoule. Cependant, le résultat attendu de « Timed out » n’est pas obtenu. Au lieu de cela, la sortie inclut à la fois le message de délai d'attente et les impressions "test" et "test1" ultérieures.

Pour comprendre pourquoi cela se produit, il est important de considérer le comportement des goroutines dans Go. Dans Go, il n'existe aucun moyen efficace d'arrêter de force une goroutine en cours d'exécution. Au lieu de cela, des mécanismes de synchronisation tels que des canaux et des mutex doivent être utilisés.

Le délai d'attente utilisé dans le code est un délai d'attente sur l'opération de réception du canal, et non sur la goroutine elle-même. Par conséquent, même si l'opération de réception expire, la goroutine qui envoyait au canal continue de s'exécuter, ce qui entraîne les impressions suivantes.

Dans cette situation, il est nécessaire de mettre en œuvre une certaine forme de synchronicité entre les goroutines. . Cela pourrait impliquer l'utilisation d'un canal de signal ou d'un contexte pour communiquer le délai d'attente à la goroutine qui exécute la tâche de longue durée, lui permettant ainsi de gérer l'annulation avec élégance.

En comprenant les limites de l'exécution de la goroutine dans Go et en employant des techniques de synchronisation appropriées, il est possible d'arrêter efficacement les goroutines en cas d'expiration.

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!