Comment le package contextuel de Go peut-il garantir la terminaison en douceur de plusieurs Goroutines ?

Synchroniser les goroutines avec le contexte

Dans Go, il y a un défi lorsque l'on travaille avec des goroutines : assurer leur terminaison ordonnée. Considérons un scénario avec plusieurs goroutines fonctionnant indépendamment, mais vous souhaitez qu'elles se synchronisent de telle sorte que lorsqu'une goroutine se termine, les autres doivent également se fermer.

L'extrait de code fourni comprend deux goroutines qui s'exécutent en permanence. Si une erreur se produit dans une goroutine, vous avez l'intention de mettre fin aux deux. L'utilisation d'un canal pour signaler l'achèvement peut entraîner des paniques dues aux écritures sur des canaux fermés.

L'approche recommandée pour de tels scénarios consiste à utiliser le package de contexte de Go, qui permet la communication entre les goroutines.

Dans Dans l'exemple de code ci-dessous, un contexte d'arrière-plan est créé avec une fonction d'annulation utilisant context.WithCancel. Un sync.WaitGroup est créé pour suivre le nombre de goroutines en cours d'exécution.

package main

import (
    "context"
    "sync"
)

func main() {

    ctx, cancel := context.WithCancel(context.Background())
    wg := sync.WaitGroup{}
    wg.Add(3)

Trois goroutines sont démarrées. Les deux premiers goroutines fonctionnent en continu, attendant un signal du contexte. Dès réception du signal, ils sortent gracieusement.

    go func() {
        defer wg.Done()
        for {
            select {
            // msg from other goroutine finish
            case <-ctx.Done():
                // end
            }
        }
    }()

    go func() {
        defer wg.Done()
        for {
            select {
            // msg from other goroutine finish
            case <-ctx.Done():
                // end
            }
        }
    }()

La troisième goroutine effectue une opération puis appelle la fonction d'annulation pour signaler l'achèvement de sa tâche. Cette action provoque la fermeture du contexte, déclenchant la sortie des deux autres goroutines.

    go func() {
        defer wg.Done()
        // your operation
        // call cancel when this goroutine ends
        cancel()
    }()

Enfin, la fonction wg.Wait attend que les trois goroutines se terminent avant la fin de la routine principale.

    wg.Wait()
}

Cette approche basée sur le contexte garantit que lorsque l'une des goroutines se termine, les autres sont averties et se terminent correctement, offrant ainsi un moyen propre et efficace de gérer synchronisation goroutine.

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!