Groupe d'attente de Golang

Golang Waitgroup vous permet de bloquer un bloc de code spécifique pour permettre à un ensemble de Goroutines de terminer l'exécution. Un exemple serait de bloquer la fonction principale jusqu'à ce que les Goroutines soient terminés, puis débloque le groupe.

Exemple 1

Prenez un exemple ci-dessous:

package principal
Importer "FMT"
funcrt ()
fmt.Println ("First Go Routine")

funcrt2 ()
fmt.Println ("deuxième routine Go")

funcmain ()
GO RT ()
aller rt2 ()

Si vous exécutez le code ci-dessus, le programme n'imprime rien. En effet, la fonction principale est terminée lors du lancement des Goroutines. Étant donné que la fonction principale est le point d'entrée d'un programme GO, une fois la fin, le programme se termine.

Pour gérer un tel cas, nous pouvons utiliser le groupe d'attente Golang. La méthode WaitGroup a trois méthodes principales:

1. Add () - le groupe d'attente agit comme un compteur tenant le nombre de fonctions ou des routines GO pour attendre. Si le compteur devient 0, le groupe d'attente libère les Goroutines. Nous utilisons la méthode ADD pour ajouter une valeur spécifique au compteur de groupe d'attente.
2. Wait () - La méthode d'attente bloque l'exécution jusqu'à ce que le compteur de groupe d'attente devienne 0.
3. Done () - diminue le compteur de groupe d'attente par une valeur de 1

Laissez maintenant recréer l'exemple précédent et utiliser WaitGroup pour suspendre l'exécution.

package principal
importer (
"FMT"
"sync"
)
Funcrt (WG * Sync.WaitGroup)
fmt.Println ("First Go Routine")
débarquer.DID () // Retirez la goroutine du compteur de groupe d'attente

funcrt2 (Wg * Sync.WaitGroup)
fmt.Println ("deuxième routine Go")
débarquer.Fait()

funcmain ()
// Nouveau groupe d'attente
wg: = new (sync.WaitGroup)
// Ajouter deux routines GO
wg.Ajouter (2)
Go RT (WG)
Go RT2 (WG)
// Bloquer l'exécution jusqu'à ce que
wg.Attendez()

Maintenant, si nous exécutons à nouveau le code, nous devrions voir une sortie comme:

$ Go Run WaitGroup.aller
Deuxième routine
Première routine

Exemple 2

Vous pouvez également utiliser des groupes d'attente avec des fonctions anonymes. Un exemple est comme indiqué ci-dessous:

package principal
importer (
"FMT"
"sync"
)
wg.Fait()
//
funcmain ()
varwgsync.Groupe d'attente
fori: = 1; je<= 5; i++
wg.Ajouter (1)
i: = i
gofunc ()
débarquer.Fait()
fmt.Printf ("Routine de démarrage:% d \ n", i)
()

wg.Attendez()

L'exemple ci-dessus illustre comment utiliser des groupes de wait avec une fonction anonyme. Le code ci-dessus doit retourner:

Routine de démarrage: 1
Routine de départ: 3
Routine de départ: 4
Routine de départ: 5
Routine de départ: 2

Conclusion

Dans cet article, nous avons couvert les bases du travail avec le sous-package WaitGroup du package de synchronisation dans Go. WaitGroups vous permet de suspendre l'exécution jusqu'à ce qu'un groupe de fonctions ou de goroutines finisse l'exécution.