Golang Sync

Das Golang -Synchronisierungspaket bietet Synchronisation -Primitive wie Mutex, Karteigruppe, Pool, Lesen und Schreiben von Mutex- und Zustandsvariablen.

Lassen Sie uns einige Funktionen in diesem Artikel erkunden.

Golang Mutex

Die Synchronisation.Mutex liefert einen Mutex -Primitiv, der gegenseitige Ausschlüsse für gemeinsame Ressourcen ermöglicht, die Rassenbedingungen verhindern.

Beispiel Verwendung:

Paket Main
"synchronisieren" importieren
func main ()
var i = 10
mutex: = & synchronisieren.Mutex
Mutex.Sperren()
// nur eine Goroutine kann gleichzeitig auf diesen Code zugreifen
ich++
Mutex.Freischalten()

Mustex lesen/schreiben

Die Synchronisation.RWMutex bietet einen Leser/Schriftsteller -Mutex. Es bietet ähnliche Methoden als primitives Mutex, kann jedoch mithilfe von Rock- und Runlock -Methoden gleichzeitige Lesevorgänge ermöglichen:

var i = 10
mutex: = & synchronisieren.Rwmutex
Mutex.Sperren()
// nur eine Goroutine kann gleichzeitig auf diesen Code zugreifen
ich++
Mutex.Freischalten()
Mutex.Rlock ()
i ++ // gleichzeitige liest
Mutex.Runlock ()

Das vorherige Beispiel kann es über eine Goroutine ermöglichen, den Code zu lesen. Im Gegensatz zu Synchronisation.Mutex, der genau einen Leser und einen Schriftsteller gleichzeitig ermöglicht.

Karteigruppen

Die Synchronisation.WaitGroup bietet einen Blockierungsmechanismus für Goroutinen an. Mit einer Karteigruppe können Sie die Ausführung einer Funktion blockieren, bis alle Goroutinen ausgeführt wurden.

Es funktioniert, indem es einen Zähler erstellt, der die Anzahl der Goroutinen zum Warten hält. Sobald eine Goroutine abgeschlossen ist, nimmt der Zähler um 1 ab. Sobald der Zähler 0 ist, blockiert die Karteigruppe die Ausführung.

Um dem Kartentisch einen Wert hinzuzufügen, können wir die Methode add () verwenden, die einen Ganzzahlwert erfordert.

Um eine Goroutine nach der Fertigstellung vom Zähler zu entfernen, verwenden wir die Done () -Methode. Zum Beispiel:

Paket Main
importieren (
"fmt"
"Synchronisation"
)
func main ()
WG: = & synchronisieren.WaitGroup
für i: = 0; ich < 5; i++
wg.(1) hinzufügen
Go func (x int)
fmt.Printf ("Arbeiter: %d lauft \ n", x)
wg.Erledigt()
(ich)

wg.Warten()

Im vorherigen Beispiel erhöhen wir den Wert des Wartgruppenschalters durch die Verwendung der Funktion add ().

Sobald eine Goroutine abgeschlossen ist, verringern wir den Zähler mit der Done () -Methode durch 1. Der vorherige Code sollte die Ausgabe als:

Arbeiter: 4 Laufen
Arbeiter: 2 Laufen
Arbeiter: 1 Laufen
Arbeiter: 3 Laufen
Arbeiter: 0 Laufen

Einmal

Die Synchronisation.Sobald Primitive sicherstellt, dass eine Funktion nur einmal ausgeführt wird. Ein Beispiel ist wie unten gezeigt:

var einmal synchronisieren.Einmal
Runonce: = func ()
fmt.Println ("einmal rennen")

fertig: = make (chan string)
für i: = 0; ich < 5; i++
go func ()
einmal.Tun (Runonce)
Erledigt <- "Hi"
())

für i: = 0; ich < 5; i++
<-done

Abschluss

Dieser Leitfaden deckt einige grundlegende und grundlegende Primitive ab, die vom Go Sync -Paket bereitgestellt werden. Darüber hinaus wurden Synchronisationsprimitive wie Mutex, Karteigruppe, Pool, Lesen und Schreiben von Mutex- und Bedingungsvariablen diskutiert. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Tutorials finden Sie in anderen Linux -Hinweisartikeln.