Comment Golang effectue l'opération d'arrêt de goroutine

Golang est un langage de programmation élégant car il offre une concurrence facile. La concurrence est au cœur de tout développement logiciel moderne, nous permettant de créer des applications hautement évolutives, maintenables et fiables. Dans Golang, il est très facile d'obtenir la concurrence via goroutine, mais l'utilisation de goroutine peut également causer certains problèmes, dont le plus courant est de savoir comment effectuer l'opération d'arrêt de goroutine.

Dans cet article, nous explorerons comment arrêter gracieusement les goroutines dans Golang. Nous présenterons deux méthodes, l'une consiste à envoyer un signal de fermeture en utilisant un canal et l'autre consiste à annuler la goroutine à l'aide de la fonction WithCancel du package de contexte. Dans le même temps, nous explorerons également comment éviter les fuites goroutines.

Fermer une goroutine à l'aide d'un canal

Tout d'abord, voyons comment utiliser un canal pour fermer une goroutine. Les canaux sont la structure de base utilisée pour la communication dans Golang. Les canaux peuvent être utilisés non seulement pour transférer des données, mais également pour transférer des signaux de commande.

Nous pouvons créer un canal pour contrôler la fermeture de goroutine. Nous pouvons boucler le goroutine et attendre le signal sur le canal. Une fois le signal reçu, le goroutine sortira. Voici un exemple de code :

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)

    go func() {
        for {
            select {
            case <-quit:
                fmt.Println("goroutine stopped")
                return
            default:
                fmt.Println("working...")
            }
            time.Sleep(1 * time.Second)
        }
    }()

    time.Sleep(5 * time.Second)
    fmt.Println("sending quit signal")
    quit <- true

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

Dans l'exemple ci-dessus, nous avons créé un canal booléen appelé quit et démarré une goroutine dans la fonction principale. La boucle goroutine attend un signal sur le canal, et une fois le signal reçu, la goroutine sortira. Dans la fonction principale, on attend 5 secondes puis on envoie une vraie valeur au canal pour déclencher l'arrêt de la goroutine. Enfin, on attend 2 secondes que le programme se termine.

Utilisez le contexte pour annuler la goroutine

Nous pouvons également utiliser la fonction context.WithCancel pour annuler la goroutine. Cette fonction renverra un contexte (Context) et une fonction d'annulation (CancelFunc). Le contexte est un type utilisé pour transmettre des informations contextuelles entre les goroutines. Nous pouvons combiner Context avec des canaux pour arrêter gracieusement les goroutines. Voici un exemple de code :

package main

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

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

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

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

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

Dans l'exemple ci-dessus, nous utilisons la fonction WithCancel dans le package de contexte pour créer un contexte et utiliser ce contexte pour démarrer une goroutine. La boucle goroutine attend la valeur de retour de la fonction Done() du contexte pour vérifier si elle doit se terminer. Un avantage supplémentaire de l'utilisation du contexte par rapport aux canaux est qu'il peut être utilisé pour transmettre des informations contextuelles (telles que l'ID de la demande, le délai d'attente, etc.).

Évitez les fuites de goroutines

À Golang, les fuites de goroutines sont un problème courant. Cela se produit lorsqu'une goroutine est annulée ou arrêtée avant de terminer ses tâches, ou qu'elle manque de threads ou de mémoire sans s'arrêter correctement.

Afin d'éviter les fuites de goroutine, nous devons considérer son cycle de vie avant de créer une goroutine. Nous devons nous assurer que la goroutine peut être libérée correctement afin que la mémoire puisse être récupérée en temps opportun. Nous devrions utiliser des canaux ou des contextes pour le contrôle et la coordination goroutines autant que possible. Lorsqu'une goroutine n'est plus nécessaire, nous devons utiliser un canal ou un contexte pour envoyer un signal afin de la laisser se terminer automatiquement.

Résumé

Dans cet article, nous avons brièvement présenté comment arrêter gracieusement les goroutines dans Golang. Nous avons exploré deux approches : utiliser des canaux et utiliser des contextes. Dans le même temps, nous avons également discuté de la manière d'éviter le problème courant des fuites de goroutines. Il s'agit d'un sujet très important pour tout développeur Golang, car contrôler correctement le cycle de vie des goroutines est très critique lors de l'écriture d'applications à haute concurrence.

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!