Golang errgroup

Golang Errgroup -pakken brukes til å gi verktøy for synkronisering, feilutbredelse og avbestilling av kontekst for en gruppe goroutiner som utfører en felles oppgave.

La oss ta en titt på en hvordan du bruker ErrGroup -pakken.

Importer påkrevd pakke

For å bruke ErrGroup -pakken, må du importere den ved å bruke importklausulen. Eksempelkoden nedenfor viser hvordan du importerer ergroup -pakken.

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

WithContext -funksjonen

ErrGroup -pakken gir oss med med Context -funksjonen. Funksjonen returnerer en ny gruppe, og den tilhørende konteksten.

Hvis funksjonen som er bestått, returnerer en ikke-null feil eller ventetiden kommer tilbake, blir konteksten kansellert.

Gå func

Den andre funksjonen levert av ErrGroup -pakken er Go -funksjonen. Denne funksjonen kaller en spesifisert funksjon til en ny goroutine.

Hvis den første samtalen returnerer ikke-nullfeil, avbryter dette konteksten.

Vent func

Den tredje funksjonen er ventefunksjonen. Denne funksjonen venter en blokk til funksjonen ringer fra GO -metoden returnerer en verdi.

Eksempel

La oss se hvordan vi kan bruke ErrGroup -pakken. La oss begynne med et sett med GO -rutiner som ganske enkelt skriver ut en verdi.

pakkehoved
Importer "FMT"
func main ()
for i: = 0; Jeg < 10; i++
Gå fmt.Println ("Behandlingsoppgave:", i)

Her har vi en for sløyfe som ganske enkelt kjører en haug med goroutines og skriver ut gjeldende verdi i loop -iterasjonen.

Hvis vi kjører koden over, merker du at den ikke skriver ut noe. Dette er fordi goroutinene er inne i hovedfunksjonen, og når hovedfunksjonen er slutt, vil GO avslutte hele programmet, enten goroutines er ferdig eller ikke.

Vi kan løse dette ved å bruke synkroniseringspakken fra standardbiblioteket. Sjekk opplæringen vår på Golang Sync for å lære mer.

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

Vi kan omdefinere koden ovenfor ved hjelp av ventegrupper som vist nedenfor:

pakkehoved
import (
"FMT"
"Synkronisering"
)
func main ()
WG: = & synkronisering.WaitGroup
for i: = 0; Jeg < 10; i++
wg.Legg til (1)
gå func (oppgave int)
utsetter wg.Gjort ()
fmt.Println ("Behandle oppgave:", oppgave)
(Jeg)

wg.Vente()

Her introduserer vi "samtidighet" ved hjelp av ventegrupper. I et nøtteskall er ventegruppen en teller som lar oss hindre hovedfunksjonen fra å gå ut til alle goroutines er ferdige.

Ventegruppen fungerer ved å lage en teller som holder traktat av antall goroutiner i Que. Når en goroutine er fullført, fjerner vi den fra Que. Når Que er 0, fjerner ventegruppen utførelsen og går tilbake til hoved.

Legg merke til tilleggsfunksjonen? Vi bruker dette for å tilføre en verdi til QuainGroup Que -telleren. Når utførelsen er ferdig, fjerner vi den fullførte goroutine ved hjelp av Done Method.

Bruke errgroup

I eksemplet ovenfor behandler vi en gruppe goroutines ved hjelp av synkroniseringspakken i Go. Det er imidlertid ingen mekanisme for å håndtere noen feil. Selv om det ikke er nødvendig for et enkelt eksempel som et vist ovenfor, er det viktig for mange applikasjoner.

For det kan vi bruke ErrGroup -funksjonen som gjør det mulig å håndtere feil i en ventegruppe. Ta en titt på eksemplet nedenfor:

pakkehoved
import (
"FMT"
"Logg"
"Matematikk/rand"
"Golang.org/x/sync/errgroup "
)
func oppgave (oppgave int) feil
Hvis rand.Intn (10) == oppgave
Return FMT.Errorf ("Oppgave %v mislyktes", oppgave)

fmt.Printf ("Oppgave %v fullført", oppgave)
Returner null

func main ()
f.eks: = & errgroup.Gruppe
for i: = 0; Jeg < 10; i++
Oppgave: = jeg
f.eks.Gå (func () feil
Returoppgave (oppgave)
)

Hvis feil: = f.eks.Vente(); feil != nil
Logg.Fatal ("Feil", feil)

fmt.Println ("Fullført vellykket!")

I dette eksemplet introduserer vi en enkel funksjon som genererer et tilfeldig heltall. Hvis den tilfeldige verdien er lik oppgaven, returnerer vi en feil.

Vi bruker deretter feilgruppen til å håndtere feilene ved å bruke gruppen og GO -funksjoner.

Lukking

Denne guiden dekket hvordan du introduserer og jobber med ventegrupper og håndterer feil ved hjelp av ergroup -pakken.