Golang errgroup

Il pacchetto Golang ErrGroup viene utilizzato per fornire strumenti per la sincronizzazione, propagazione degli errori e cancellazione del contesto per un gruppo di goroutine che eseguono un compito comune.

Diamo un'occhiata a come utilizzare il pacchetto ErrGroup.

Pacchetto richiesto di importazione

Per utilizzare il pacchetto ErrGroup, è necessario importarlo utilizzando la clausola di importazione. Il codice di esempio seguente mostra come importare il pacchetto ErrGroup.

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

ConContext Function

Il pacchetto ErrGroup ci fornisce la funzione WithContext. La funzione restituisce un nuovo gruppo e il contesto associato.

Se la funzione passata restituisce un errore non 0-NIL o i restituzioni di attesa, il contesto viene annullato.

Vai func

La seconda funzione fornita dal pacchetto ErrGroup è la funzione GO. Questa funzione chiama una funzione specificata a una nuova goroutine.

Se la prima chiamata restituisce un errore non NIL, questo annulla il contesto.

Aspetta func

La terza funzione è la funzione di attesa. Questa funzione attende un blocco fino a quando la funzione chiama dal metodo GO restituisce un valore.

Esempio

Vediamo come possiamo usare il pacchetto ErrGroup. Cominciamo con una serie di routine GO che stampano semplicemente un valore.

Pacchetto principale
Importa "FMT"
func main ()
per i: = 0; io < 10; i++
vai a fmt.Println ("attività di elaborazione:", i)

Qui, abbiamo un ciclo per gestire semplicemente un mucchio di goroutine e stampare il valore corrente nell'iterazione del loop.

Se eseguiamo il codice sopra, noti che effettivamente non stampano nulla. Questo perché le goroutine sono all'interno della funzione principale e una volta termina la funzione principale, GO terminerà l'intero programma, indipendentemente dal fatto che le goleoutine abbiano finito.

Possiamo risolverlo utilizzando il pacchetto di sincronizzazione dalla libreria standard. Controlla il nostro tutorial sulla sincronizzazione di Golang per saperne di più.

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

Possiamo ridefinire il codice sopra usando i Waitgroup come mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
func main ()
WG: = & Sync.Waitgroup
per i: = 0; io < 10; i++
Wg.Aggiungi (1)
go func (task int)
Defer Wg.Fatto()
fmt.Println ("attività di elaborazione:", attività)
(io)

Wg.Aspettare()

Qui, introduciamo la "concorrenza" usando i camerieri. In poche parole, il waitgroup è un contatore che ci consente di bloccare l'uscita della funzione principale fino a quando tutte le goroutine non hanno terminato l'esecuzione.

Il waitgroup funziona creando un contatore che mantiene il tratto del numero di goroutine nella que. Una volta completata una goroutine, la rimuoviamo dalla que. Una volta che la que è 0, il waitgroup sblocca l'esecuzione e ritorna al principale.

Notare la funzione Aggiungi? Usiamo questo per aggiungere un valore al contatore. Una volta eseguita l'esecuzione, rimuoviamo la goroutine completata usando il metodo fatto.

Usando errgroup

Nell'esempio sopra, elaboriamo un gruppo di goroutine utilizzando il pacchetto di sincronizzazione in GO. Tuttavia, non esiste un meccanismo per gestire alcun errore. Sebbene non sia necessario per un semplice esempio come mostrato sopra, è importante per molte applicazioni.

Per questo, possiamo utilizzare la funzione ErrGroup che consente di gestire gli errori in un gruppo di attesa. Dai un'occhiata all'esempio seguente:

Pacchetto principale
importazione (
"FMT"
"tronco d'albero"
"matematica/rand"
"Golang.org/x/sync/errgroup "
)
Func Task (Task int) Errore
Se Rand.Intn (10) == Task
restituire fmt.ERRIRF ("Task %v non riuscito", attività)

fmt.Printf ("attività %v completata", attività)
Restituisci zero

func main ()
ad esempio: = & errgroup.Gruppo
per i: = 0; io < 10; i++
Attività: = i
per esempio.Go (func () errore
Attività di restituzione (attività)
)

Se err: = EG.Aspettare(); err != nil
tronco d'albero.Fatale ("errore", err)

fmt.Println ("completato correttamente!")

In questo esempio, introduciamo una funzione semplice che genera un numero intero casuale. Se il valore casuale è uguale all'attività, restituiamo un errore.

Quindi utilizziamo il gruppo di errore per gestire gli errori usando il gruppo e le funzioni.

Chiusura

Questa guida ha coperto come introdurre e lavorare con waitgroups e gestire errori utilizzando il pacchetto ErrGroup.