Maison > développement back-end > Golang > Comment le package contextuel de Go peut-il garantir la terminaison en douceur de plusieurs Goroutines ?

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

Barbara Streisand
Libérer: 2024-12-04 17:02:11
original
173 Les gens l'ont consulté

How Can Go's Context Package Ensure Graceful Termination of Multiple 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)
Copier après la connexion

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
            }
        }
    }()
Copier après la connexion

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()
    }()
Copier après la connexion

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

    wg.Wait()
}
Copier après la connexion

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal