La coroutine Golang se ferme

En langage Go, la coroutine est un mécanisme de programmation simultanée important. Il permet d'exécuter plusieurs tâches en parallèle, améliorant ainsi l'efficacité du programme. L'implémentation des coroutines du langage Go est basée sur des threads légers (ou threads au niveau utilisateur), de sorte que le coût de création et de destruction des coroutines est très faible. Cependant, dans le développement réel, nous devons parfois fermer la coroutine en cours d'exécution, et dans ce cas, nous devons utiliser des moyens spéciaux pour y parvenir. Cet article présente quelques méthodes et techniques concernant l'arrêt de la coroutine Golang.

1. L'essence des coroutines

Avant de comprendre la méthode de fermeture des coroutines, nous devons d'abord comprendre la nature des coroutines. Une coroutine est essentiellement un thread d’exécution indépendant qui s’exécute en parallèle avec le thread principal. Chaque coroutine possède sa propre pile et ses propres variables locales, mais elles partagent le même processus et les mêmes variables globales. La création et la destruction de coroutines ne nécessitent que quelques instructions, elles sont donc très efficaces.

2. Comment fermer la coroutine

1. Fermez la coroutine via context.Context

En langage Go, vous pouvez utiliser context.Context pour contrôler le fonctionnement de la coroutine. Un Contexte avec fonction d'annulation peut être créé via la fonction context.WithCancel Lorsque la fonction Cancel du Context est appelée, toutes les coroutines qui dépendent du Context seront fermées. Voici un exemple de code simple :

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        for {
            select {
            case <-ctx.Done():
                log.Println("The goroutine is stopped.")
                return
            default:
                // do something
            }
        }
    }()
    time.Sleep(time.Second)
    cancel()
    time.Sleep(time.Second)
}

Dans cet exemple, nous créons un Contexte avec une fonction d'annulation et créons une coroutine dans laquelle certaines opérations sont effectuées en continu jusqu'à ce que le Contexte soit annulé. Attendez une seconde dans le thread principal, puis appelez la fonction Cancel de Context pour fermer la coroutine.

2. Fermez la coroutine via le canal

En plus d'utiliser context.Context pour contrôler le fonctionnement de la coroutine, vous pouvez également utiliser des canaux pour l'implémenter. Normalement, nous pouvons créer un canal de type booléen pour transmettre le signal de fermeture ou non de la coroutine. Lorsque le thread principal appelle la fonction close du canal, toutes les coroutines lisant le canal recevront un signal de valeur nulle et quitteront. Voici un exemple de code :

func main() {
    stopCh := make(chan bool)
    go func() {
        for {
            select {
            case <-stopCh:
                log.Println("The goroutine is stopped.")
                return
            default:
                // do something
            }
        }
    }()
    time.Sleep(time.Second)
    close(stopCh)
    time.Sleep(time.Second)
}

Dans cet exemple, nous créons un canal de type booléen pour transmettre le signal de fermeture ou non de la coroutine. Dans la coroutine, utilisez l'instruction select pour vérifier en permanence si le canal est fermé et, s'il est fermé, quittez. Attendez une seconde dans le thread principal puis appelez la fonction close du canal pour fermer la coroutine.

3. Fermez la coroutine via sync.WaitGroup

En plus d'utiliser context.Context et canal pour contrôler le fonctionnement de la coroutine, vous pouvez également utiliser sync.WaitGroup. WaitGroup est un compteur qui peut être utilisé pour attendre la fin d'un groupe de coroutines. Plus précisément, lorsque la coroutine est créée, le compteur du WaitGroup est incrémenté de un, et une fois la coroutine exécutée, le compteur est décrémenté de un. Dans le thread principal, appelez la fonction Wait de WaitGroup pour attendre la fin de l'exécution de toutes les coroutines, puis fermez le programme. Voici un exemple de code :

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            // do something
        }
    }()
    time.Sleep(time.Second)
    wg.Done()
    wg.Wait()
}

Dans cet exemple, nous créons un WaitGroup et incrémentons le compteur de un. Dans la coroutine, effectuez certaines opérations, attendez la fin de la coroutine et appelez la fonction Done de WaitGroup pour décrémenter le compteur de un. Attendez une seconde dans le thread principal avant d'appeler la fonction Done de WaitGroup, puis appelez la fonction Wait pour attendre que toutes les coroutines terminent leur exécution, puis fermez le programme.

3. Résumé

La coroutine du langage Go est un mécanisme de programmation simultanée très puissant et est largement utilisé dans le développement. Cependant, dans le développement réel, nous devons parfois fermer la coroutine en cours d'exécution, et dans ce cas, nous devons utiliser des moyens spéciaux pour y parvenir. Cet article présente quelques méthodes et techniques pour fermer les coroutines Golang. J'espère qu'il sera utile à tout le monde.

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!