Der Golang Mutex

Eine Rennbedingung bezieht sich auf eine Instanz, in der mehr als ein Thread versucht, auf gemeinsame Daten zuzugreifen.

In diesem Artikel werden wir die Grundlagen der Implementierung eines Mutex mithilfe des GO -Synchronisierungspakets diskutieren.

Golang Sync -Paket

Das SYNC -Paket in Go bietet uns Tools und Methoden zur Implementierung von Synchronisationsaufgaben wie Karteigruppen und gegenseitige Ausschlüsse.

Für diesen Artikel interessieren wir uns nur kurz an den gegenseitigen Ausschließungen oder mutex. Das Sync -Paket bietet uns zwei Methoden, um Mutex in den GO -Programmen zu implementieren:

1. Sperren()
2. Freischalten()

Wenn Sie einen Code zwischen den Sperr- und Entsperrenmethoden platzieren, können GO -Programme nur einen einzelnen Thread oder Goroutine ermöglichen, auf diesen Code zuzugreifen.

Lassen Sie uns ein einfaches Programm mit Rennbedingungen nehmen:

Paket Main
importieren (
"fmt"
"Synchronisation"
)
var x = 1
Func Add (WG *Sync.WaitGroup)
X++
wg.Erledigt()

func main ()
Var WaitGroup Sync.WaitGroup
für i: = 0; ich < 10000; i++
WaitGroup.(1) hinzufügen
Gehen Sie hinzufügen (& WaitGroup)

WaitGroup.Warten()
fmt.Println (x)

Im vorherigen Beispiel haben wir eine Funktion, die den Wert von x übernimmt und ihn um 1 erhöht. Die Funktion fordert die Karteigruppe dann auf.

In der Hauptfunktion führen wir gleichzeitig mindestens 10.000 Goroutinen aus, wobei jeder versucht, auf den Wert von x zuzugreifen und zu ändern.

Da es keine deterministische Reihenfolge gibt, um die Goroutinen auszuführen.

Um für die vorherige Rennbedingung zu lösen, können wir wie unten gezeigt einen Mutex verwenden:

Paket Main
importieren (
"fmt"
"Synchronisation"
)
var x = 1
Func Add (WG *Sync.WAITGROUP, MX *Synchronisierung.Mutex)
// Zugriff auf diesen Wert sperren
mx.Sperren()
X++
mx.Freischalten()
wg.Erledigt()

func main ()
Var WaitGroup Sync.WaitGroup
var mutex sync.Mutex
für i: = 0; ich < 10000; i++
WaitGroup.(1) hinzufügen
Go Add (& WaitGroup & Mutex)

WaitGroup.Warten()
fmt.Println (x)

Hier fügen wir MX von Typsynchronisation hinzu.Mutex zur add add -Funktion. Dann sperren wir den Inkrementoperator, um eine einzelne Goroutine gleichzeitig zu ermöglichen.

Schließen

Dieser Artikel behandelte die Grundlagen der Implementierung eines Mutex in GO mithilfe des Sync -Pakets, um eine einfache Rennbedingung zu beheben. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Informationen finden Sie in anderen Linux -Hinweisartikeln.