Comment fermer la coroutine dans Golang

Avec la popularité de Golang ces dernières années, de plus en plus de personnes ont commencé à comprendre et à utiliser Golang. Parmi elles, les coroutines sont une fonctionnalité majeure du langage Golang. Son implémentation légère de threads rend l'utilisation des coroutines très flexible et efficace. Cependant, lors de l'utilisation de coroutines, il est parfois nécessaire de fermer manuellement les coroutines afin de libérer des ressources et d'éviter des problèmes tels que des fuites de mémoire. Cet article présentera plusieurs méthodes et techniques pour fermer les coroutines dans Golang.

1. Utilisez le canal pour fermer la coroutine

Dans Golang, vous pouvez utiliser le canal pour fermer la coroutine. Cette méthode est très simple. Il suffit de définir un canal de type booléen pour contrôler la fermeture de la coroutine, et de détecter en continu l'état de ce canal dans la coroutine. Lorsque le canal est fermé, la coroutine se ferme.

Ce qui suit est un exemple de code :

package main

import (
    "fmt"
    "time"
)

func worker(stop chan bool) {
    for {
        select {
        case <-stop:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    stop := make(chan bool)
    go worker(stop)

    time.Sleep(5 * time.Second)
    fmt.Println("stop worker")
    close(stop)

    time.Sleep(5 * time.Second)
    fmt.Println("program exited")
}

Dans le code ci-dessus, nous définissons une fonction de travail comme une coroutine et passons un canal de type bool stop chan. Dans la fonction Worker, nous utilisons l'instruction select pour écouter le canal d'arrêt. Si le canal est fermé, quittez la coroutine. Dans la fonction principale, nous avons créé un canal d'arrêt et démarré une coroutine de travail via le mot-clé go. Après avoir attendu 5 secondes, nous fermons le canal d'arrêt dans la fonction principale, arrêtant ainsi la coroutine de travail. Après une dernière attente de 5 secondes, le programme se termine.

2. Utiliser le contexte pour annuler les coroutines

En plus d'utiliser des canaux, le contexte peut également être utilisé dans Golang pour annuler les coroutines. Context fournit une méthode standard qui permet de transmettre des délais d'attente, des signaux d'annulation et d'autres valeurs sur la portée de la requête de la coroutine en cours d'exécution.

Voici un exemple de code :

package main

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

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker canceled")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)

    time.Sleep(5 * time.Second)
    fmt.Println("cancel worker")
    cancel()

    time.Sleep(5 * time.Second)
    fmt.Println("program exited")
}

Dans le code ci-dessus, nous utilisons la fonction context.WithCancel pour créer un contexte avec un signal d'annulation et le transmettre à la fonction worker. Dans la fonction de travail, nous utilisons l'instruction select pour écouter le canal context.Done() Si le contexte est annulé, quittez la coroutine. Dans la fonction principale, nous appelons la fonction Cancel pour annuler le contexte et ainsi arrêter la coroutine de travail.

3. Utilisez sync.WaitGroup pour implémenter l'attente de coroutine

Dans Golang, utiliser sync.WaitGroup pour implémenter l'attente de coroutine est également une méthode courante. Lorsque la coroutine démarre, le compteur WaitGroup est augmenté de 1 ; lorsque la coroutine se termine, le compteur est décrémenté de 1. Lorsque le compteur atteint 0, cela indique que toutes les coroutines sont terminées et que la fonction principale peut continuer son exécution.

Voici un exemple de code :

package main

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

func worker(wg *sync.WaitGroup, stop chan bool) {
    defer wg.Done()

    for {
        select {
        case <-stop:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    wg := sync.WaitGroup{}
    stop := make(chan bool)

    wg.Add(1)
    go worker(&wg, stop)

    time.Sleep(5 * time.Second)
    fmt.Println("stop worker")
    stop <- true

    wg.Wait()
    fmt.Println("program exited")
}

Dans le code ci-dessus, nous utilisons sync.WaitGroup pour attendre la sortie de la coroutine de travail. Dans la fonction de travail, nous utilisons l'instruction defer pour décrémenter le compteur WaitGroup lorsque la coroutine se termine. Dans la fonction principale, nous augmentons d'abord le compteur WaitGroup de 1, puis appelons le mot-clé go pour démarrer la coroutine de travail. Après avoir attendu 5 secondes, nous envoyons un message de type booléen au canal d'arrêt pour arrêter la coroutine de travail. Enfin, on attend que le compteur WaitGroup devienne 0, mettant ainsi fin au programme.

En résumé, cet article présente plusieurs méthodes de fermeture de coroutines dans Golang, notamment l'utilisation de canaux pour implémenter la fermeture de coroutine, l'utilisation du contexte pour implémenter l'annulation de coroutine et l'utilisation de sync.WaitGroup pour implémenter l'attente de coroutine. Dans les projets réels, il est nécessaire de choisir la méthode appropriée pour fermer les coroutines en fonction de scénarios commerciaux et de besoins spécifiques afin d'éviter les fuites de ressources et d'améliorer les performances du programme.

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!