Golang errgroup

Le package Golang Errgroup est utilisé pour fournir des outils pour la synchronisation, la propagation des erreurs et l'annulation du contexte pour un groupe de goroutines qui effectuent une tâche commune.

Jetons un coup d'œil à un comment utiliser le package ErrGroup.

Importer le package requis

Pour utiliser le package ErrGroup, vous devez l'importer à l'aide de la clause d'importation. L'exemple de code ci-dessous montre comment importer le package ErrGroup.

Importer "Golang.org / x / sync / errgroup "

Fonction avec Contexte

Le package ErrGroup nous fournit la fonction WithContext. La fonction renvoie un nouveau groupe et le contexte associé.

Si la fonction passée renvoie une erreur non 0-nil ou que l'attente revient, le contexte est annulé.

Aller func

La deuxième fonction fournie par le package ErrGroup est la fonction GO. Cette fonction appelle une fonction spécifiée à un nouveau goroutine.

Si le premier appel renvoie l'erreur non-NIL, cela annule le contexte.

Attendez le func

La troisième fonction est la fonction d'attente. Cette fonction attend un bloc jusqu'à ce que les appels de la fonction de la méthode GO renvoie une valeur.

Exemple

Voyons comment nous pouvons utiliser le package ErrGroup. Commençons par un ensemble de routines GO qui impriment simplement une valeur.

package principal
Importer "FMT"
func main ()
pour i: = 0; je < 10; i++
aller fmt.Println ("Tâche de traitement:", i)

Ici, nous avons une boucle pour une boucle qui exécute simplement un tas de goroutines et imprime la valeur actuelle dans l'itération de la boucle.

Si nous exécutons le code ci-dessus, vous remarquez qu'il n'imprime rien. En effet.

Nous pouvons résoudre ceci en utilisant le package Sync à partir de la bibliothèque standard. Consultez notre tutoriel sur Golang Sync pour en savoir plus.

https: // linuxhint.com / golang-sync /

Nous pouvons redéfinir le code ci-dessus à l'aide de groupes d'attente comme indiqué ci-dessous:

package principal
importer (
"FMT"
"sync"
)
func main ()
wg: = & sync.WaitGroup
pour i: = 0; je < 10; i++
wg.Ajouter (1)
Go Func (tâche int)
différer WG.Fait()
fmt.Println ("Tâche de traitement:", tâche)
(je)

wg.Attendez()

Ici, nous introduisons la «concurrence» en utilisant des groupes d'attente. En un mot, le groupe d'attente est un compteur qui nous permet de bloquer la fonction principale de quitter jusqu'à ce que tous les Goroutines aient fini d'exécuter.

Le groupe d'attente fonctionne en créant un compteur qui maintient le nombre du nombre de goroutines dans le Que. Une fois un goroutine terminé, nous le supprimons du Que. Une fois que le Que est 0, le groupe d'attente débloque l'exécution et revient à Main.

Remarquez la fonction Ajouter? Nous l'utilisons pour ajouter une valeur au compteur de WaitGroup Que. Une fois l'exécution terminée, nous supprimons le goroutine terminé à l'aide de la méthode Done.

En utilisant ErrGroup

Dans l'exemple ci-dessus, nous traitons un groupe de Goroutines en utilisant le package de synchronisation dans Go. Cependant, il n'y a pas de mécanisme pour gérer les erreurs. Bien qu'il ne soit pas nécessaire pour un exemple simple comme illustré ci-dessus, il est important pour de nombreuses applications.

Pour cela, nous pouvons utiliser la fonction ErrGroup qui permet de gérer les erreurs dans un groupe d'attente. Jetez un œil à l'exemple ci-dessous:

package principal
importer (
"FMT"
"enregistrer"
"Math / Rand"
"Golang.org / x / sync / errgroup "
)
Func Task (tâche int) Erreur
Si Rand.Intn (10) == tâche
retourner fmt.Errorf ("tâche% v échec", tâche)

fmt.Printf ("tâche% V terminée", tâche)
retour nil

func main ()
par exemple: = & errgroup.Grouper
pour i: = 0; je < 10; i++
Tâche: = I
par exemple.Go (func () error
tâche de retour (tâche)
)

Si err: = par exemple.Attendez(); se tromper != nil
enregistrer.Fatal ("erreur", err)

fmt.Println ("terminé avec succès!")

Dans cet exemple, nous introduisons une fonction simple qui génère un entier aléatoire. Si la valeur aléatoire est égale à la tâche, nous renvoyons une erreur.

Nous utilisons ensuite le groupe d'erreur pour gérer les erreurs à l'aide du groupe et des fonctions GO.

Fermeture

Ce guide a couvert comment introduire et travailler avec des groupes d'attente et gérer les erreurs à l'aide du package ErrGroup.