Il golang mutex

Un mutex si riferisce a un meccanismo di bloccaggio che garantisce che una sola funzione o goroutine sta accedendo a una sezione specifica di un programma alla volta. È una parte fondamentale della gestione della concorrenza che impedisce le condizioni di razza.

Una condizione di gara si riferisce a un'istanza in cui più di un thread tenta di accedere ai dati condivisi.

In questo articolo, discuteremo le basi dell'implementazione di un mutex utilizzando il pacchetto di sincronizzazione Go.

Pacchetto di sincronizzazione di Golang

Il pacchetto di sincronizzazione in Go ci fornisce strumenti e metodi per implementare attività di sincronizzazione, come i camerieri ed esclusioni reciproche.

Per questo articolo, siamo interessati solo ai blocchi di esclusioni reciproche o mutex in breve. Il pacchetto di sincronizzazione ci fornisce due metodi per implementare Mutex nei programmi GO:

1. Serratura()
2. Sbloccare()

Se si inserisce qualsiasi codice tra i metodi di blocco e sblocca, i programmi GO consentiranno a un solo thread o goroutine di accedere a tale codice.

Prendiamo un semplice programma con le condizioni di gara:

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
var x = 1
Func Add (WG *Sync.Waitgroup)
X++
Wg.Fatto()

func main ()
Var WaitaGroup Sync.Waitgroup
per i: = 0; io < 10000; i++
Waitgroup.Aggiungi (1)
vai ad aggiungere (& waitgroup)

Waitgroup.Aspettare()
fmt.Println (x)

Nell'esempio precedente, abbiamo una funzione che prende il valore di X e lo incrementa di 1. La funzione quindi dice al Gruppo WAITH di sbloccare il meccanismo di attesa usando la funzione Done ().

All'interno della funzione principale, eseguiamo almeno 10.000 goroutine contemporaneamente, ognuna che cerca di accedere e modificare il valore di x.

Poiché non esiste un ordine deterministico per eseguire le goroutine, il (incremento del valore di x) di x cambia in ogni esecuzione.

Per risolvere la condizione di gara precedente, possiamo usare un mutex come mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
"Sincronizzazione"
)
var x = 1
Func Add (WG *Sync.Waitgroup, Mx *Sync.Mutex)
// blocca l'accesso a questo valore
MX.Serratura()
X++
MX.Sbloccare()
Wg.Fatto()

func main ()
Var WaitaGroup Sync.Waitgroup
Var Mutex Sync.Mutex
per i: = 0; io < 10000; i++
Waitgroup.Aggiungi (1)
vai ad aggiungere (& waitgroup, & mutex)

Waitgroup.Aspettare()
fmt.Println (x)

Qui, aggiungiamo MX di tipo di sincronizzazione.Mutex alla funzione aggiungi. Quindi, blocciamo l'operatore di incremento per consentire una singola goroutine alla volta.

Chiusura

Questo articolo ha coperto i fondamenti dell'implementazione di un mutex in Go utilizzando il pacchetto di sincronizzazione per correggere una semplice condizione di gara. Speriamo che tu abbia trovato questo articolo utile. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.