Programmation simultanée Golang, gestion pratique du cycle de vie des Goroutines

Golang Concurrent Programming Gestion pratique du cycle de vie des Goroutines

Dans Golang, les Goroutines (coroutines) sont le concept clé pour atteindre la concurrence. Les Goroutines permettent aux développeurs d'effectuer plusieurs tâches en même temps de manière concise et efficace, mais en même temps, le cycle de vie des Goroutines doit être raisonnablement géré pour éviter les fuites de ressources et l'instabilité.

Cet article expliquera comment gérer le cycle de vie des Goroutines dans Golang, y compris la création, le contrôle, l'attente et la fin des coroutines. Parallèlement, nous fournissons des exemples de code pour aider les lecteurs à mieux comprendre et appliquer ces concepts.

1. Création de Goroutines
   Dans Golang, créer une Goroutine est très simple. Ajoutez simplement le mot-clé "go" avant l'appel de fonction pour l'envelopper dans une coroutine. Par exemple, le code suivant montre comment créer une coroutine pour exécuter une fonction simultanément :

package main

import "fmt"

func main() {
    go printMessage("Hello, Goroutines!")
    fmt.Println("This is the main function.")
}

func printMessage(message string) {
    fmt.Println(message)
}

Dans l'exemple ci-dessus, nous avons utilisé le mot-clé "go" pour créer une coroutine pour exécuter la fonction printMessage simultanément pendant que la fonction principale continue d'implémenter . De cette façon, « Ceci est la fonction principale. » sera imprimé en premier, puis « Bonjour, Goroutines ! » sera imprimé.

2. Contrôler les Goroutines
   Dans certains cas, nous pouvons avoir besoin de contrôler l'ordre d'exécution des Goroutines ou de contrôler leur nombre de simultanéités. Les chaînes en Golang sont un moyen très courant de nous aider à atteindre ces objectifs.

L'exemple suivant montre comment utiliser des canaux pour contrôler l'ordre d'exécution de deux coroutines :

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go printMessage("Hello", done)
    go printMessage("Goroutines", done)

    <-done
    <-done
}

func printMessage(message string, done chan bool) {
    fmt.Println(message)
    time.Sleep(time.Second)
    done <- true
}

Dans l'exemple ci-dessus, nous avons créé un canal terminé pour synchroniser l'exécution des coroutines. A la fin de chaque coroutine, nous enverrons une valeur booléenne true dans le canal terminé. Dans la fonction principale, en recevant la valeur booléenne du canal terminé, nous pouvons nous assurer que les deux coroutines s'exécutent dans l'ordre.

3. Attente de la fin des Goroutines
   Dans certains cas, nous devrons peut-être attendre la fin de l'exécution de tous les Goroutines avant de continuer à exécuter le code suivant. Golang fournit un type WaitGroup qui peut nous aider à atteindre cet objectif.

L'exemple suivant montre comment utiliser WaitGroup pour attendre la fin de l'exécution de toutes les coroutines :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go printMessage("Hello", &wg)
    go printMessage("Goroutines", &wg)
    wg.Wait()
}

func printMessage(message string, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println(message)
}

Dans l'exemple ci-dessus, nous créons d'abord une variable WaitGroup wg et utilisons sa méthode Add pour définir le nombre de coroutines à attendre à 2. . Ensuite, dans chaque fonction coroutine, utilisez l'instruction defer pour appeler la méthode Done de WaitGroup, indiquant que l'exécution de la coroutine est terminée. Enfin, appelez la méthode Wait pour attendre que toutes les coroutines terminent leur exécution.

4. Fin des Goroutines
   Parfois, nous souhaitons mettre fin activement à une coroutine en cours d'exécution. Le package de contexte de Golang fournit un moyen de terminer les coroutines en douceur.

L'exemple suivant montre comment terminer une coroutine à l'aide du package de contexte :

package main

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

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

    go printMessage(ctx, "Hello")

    time.Sleep(time.Second * 2)
    cancel()

    time.Sleep(time.Second)
    fmt.Println("Main goroutine ended.")
}

func printMessage(ctx context.Context, message string) {
    for {
        select {
        case <-ctx.Done():
            return
        default:
            fmt.Println(message)
            time.Sleep(time.Second)
        }
    }
}

Dans l'exemple ci-dessus, nous avons créé un ctx de contexte et une fonction d'annulation à l'aide de la fonction WithCancel du package de contexte. Dans la coroutine printMessage, utilisez l'instruction select pour écouter le canal ctx.Done() Une fois le signal de fermeture reçu, la coroutine se terminera.

En appelant la fonction d'annulation, vous pouvez envoyer un signal d'arrêt à ctx pour mettre fin à l'exécution de la coroutine.

Résumé :
Dans cet article, nous avons présenté comment gérer le cycle de vie des Goroutines dans Golang, y compris la création, le contrôle, l'attente et la fin des coroutines. En gérant correctement les Goroutines, nous pouvons éviter les fuites de ressources et l'instabilité et améliorer la fiabilité et les performances des programmes.

Avec des exemples de code pratiques, je pense que les lecteurs peuvent mieux comprendre et appliquer ces concepts. Dans le développement actuel, une gestion raisonnable du cycle de vie des Goroutines contribuera à améliorer la qualité d'écriture et les performances des programmes concurrents.

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!