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.
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é.
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.
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.
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!