Sincronizzazione di Golang

Il pacchetto di sincronizzazione Golang fornisce primitivi di sincronizzazione, come mutex, waitgroup, pool, lettura e scrittura mutex e variabili di condizione.

Esploriamo alcune funzionalità fornite in questo articolo.

Golang Mutex

La sincronizzazione.Mutex fornisce un primitivo mutex, che consente esclusioni reciproche per le risorse condivise che impediscono le condizioni di gara.

Esempio di utilizzo:

Pacchetto principale
importare "sincronizzazione"
func main ()
var i = 10
mutex: = & sync.Mutex
mutex.Serratura()
// solo una goroutine può accedere a questo codice alla volta
io++
mutex.Sbloccare()

Leggi/scrivi mutex

La sincronizzazione.Rwmutex fornisce un lettore/scrittore mutex. Offre metodi simili a un Mutex primitivo ma può consentire letture simultanee usando i metodi Rlock e Runlock:

var i = 10
mutex: = & sync.Rwmutex
mutex.Serratura()
// solo una goroutine può accedere a questo codice alla volta
io++
mutex.Sbloccare()
mutex.Rlock ()
I ++ // Letture simultanee
mutex.Runlock ()

L'esempio precedente può consentire a una goroutine di leggere il codice. A differenza della sincronizzazione.Mutex, che consente esattamente un lettore e uno scrittore alla volta.

Camerieri

La sincronizzazione.Waitgroup viene utilizzato per offrire un meccanismo di blocco per le goroutine. Utilizzando un Waitgroup, è possibile bloccare l'esecuzione di una funzione fino a quando tutte le goroutine non hanno terminato l'esecuzione.

Funziona creando un contatore che contiene il numero di goroutine da aspettare. Una volta completato una goroutine, il contatore diminuisce di 1. Una volta che il contatore è 0, il waitgroup sblocca l'esecuzione.

Per aggiungere un valore al contatore WaitGroup, possiamo usare il metodo ADD (), che prende un valore intero.

Per rimuovere una goroutine dal bancone dopo il completamento, utilizziamo il metodo Done (). Per esempio:

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
func main ()
WG: = & Sync.Waitgroup
per i: = 0; io < 5; i++
Wg.Aggiungi (1)
go func (x int)
fmt.Printf ("lavoratore: %d in esecuzione \ n", x)
Wg.Fatto()
(io)

Wg.Aspettare()

Nell'esempio precedente, incrediamo il valore del contatore del waitgroup di 1 attraverso l'uso della funzione ADD ().

Una volta completato una goroutine, diminuiamo il contatore di 1 usando il metodo Done (). Il codice precedente dovrebbe restituire l'output come:

Lavoratore: 4 in esecuzione
Lavoratore: 2 in esecuzione
Lavoratore: 1 corsa
Lavoratore: 3 in esecuzione
Lavoratore: 0 in esecuzione

Una volta

La sincronizzazione.Una volta primitivo garantisce che una funzione funzioni solo una volta. Un esempio è come mostrato di seguito:

var una volta sincronizzato.Una volta
Runonce: = func ()
fmt.Println ("esegui una volta")

fatto: = make (chan string)
per i: = 0; io < 5; i++
go func ()
una volta.Do (runonce)
Fatto <- "Hi"
()

per i: = 0; io < 5; i++
<-done

Conclusione

Questa guida copre alcune primitive di base e fondamentale fornite dal pacchetto Go Sync. Inoltre, sono stati discussi primitivi di sincronizzazione, come mutex, waitgroup, pool, lettura e scrittura mutex e variabili di condizione. Speriamo che tu abbia trovato questo articolo utile. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.