Golang Waitagroup

Golang Waitgroup consente di bloccare un blocco di codice specifico per consentire a una serie di goroutine di completare l'esecuzione. Un esempio sarebbe quello di bloccare la funzione principale fino al completamento delle goroutine e quindi sblocca il gruppo.

Esempio 1

Prendi un esempio di seguito:

Pacchetto principale
Importa "FMT"
funcrt ()
fmt.Println ("First Go routine")

funcrt2 ()
fmt.Println ("seconda routine Go")

funcmain ()
go rt ()
go rt2 ()

Se si esegue il codice sopra, il programma non stampa nulla. Questo perché la funzione principale viene terminata al momento dell'avvio delle goroutine. Poiché la funzione principale è il punto di ingresso di un programma GO, una volta terminata, il programma termina.

Per gestire un tale caso, possiamo usare Golang Waitgroup. Il metodo Waitgroup ha tre metodi principali:

1. ADD () - Il WaitGroup funge da contatore che tiene il numero di funzioni o vai per aspettare. Se il contatore diventa 0, il waitgroup rilascia le goroutine. Utilizziamo il metodo ADD per aggiungere un valore specifico al contatore dei waitgroup.
2. Wait () - Il metodo di attesa blocca l'esecuzione fino a quando il contatore Waitgroup non diventa 0.
3. Done () - diminuisce il contatore dei camerieri di un valore di 1

Ricreiamo ora l'esempio precedente e utilizziamo i waitgroup per mettere in pausa l'esecuzione.

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
funcrt (wg *sync.Waitgroup)
fmt.Println ("First Go routine")
Deferwg.Done () // Rimuovi la goroutine dal contatore dei camerieri

funcrt2 (WG *Sync.Waitgroup)
fmt.Println ("seconda routine Go")
Deferwg.Fatto()

funcmain ()
// Nuovo Waitgroup
WG: = new (Sync.Waitgroup)
// Aggiungi due routine GO
Wg.Aggiungi (2)
go rt (wg)
go rt2 (WG)
// Blocca l'esecuzione fino a quando non
Wg.Aspettare()

Ora, se eseguiamo di nuovo il codice, dovremmo vedere un output come:

$ go run waitgroup.andare
Routine del secondo GO
Prima routine di GO

Esempio 2

Puoi anche usare i camerieri con funzioni anonime. Un esempio è come mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
Wg.Fatto()
//
funcmain ()
varwgsync.Waitgroup
fori: = 1; io<= 5; i++
Wg.Aggiungi (1)
i: = i
gofunc ()
Deferwg.Fatto()
fmt.Printf ("routine di partenza: %d \ n", i)
()

Wg.Aspettare()

L'esempio sopra illustra come utilizzare i camerieri con una funzione anonima. Il codice sopra dovrebbe restituire:

Routine di partenza: 1
Routine di partenza: 3
Routine di partenza: 4
Routine di partenza: 5
Routine di partenza: 2

Conclusione

In questo articolo, abbiamo trattato le basi del lavoro con il sottoppackage del pacchetto di sincronizzazione in GO. Waitgroups consente di mettere in pausa l'esecuzione fino a quando un gruppo di funzioni o goroutine finisce l'esecuzione.