Die Standardmethode zum Schutz kritischer Abschnitte in GO besteht darin, die Sync.Mutex -Methoden lock () und entsperr () zu verwenden. 1. Deklarieren Sie einen Mutex und verwenden Sie ihn mit den Daten, die geschützt werden sollen. 2. Rufen Sie Lock () vor, bevor Sie in den kritischen Bereich eintreten, um sicherzustellen, dass nur eine Goroutine auf die gemeinsam genutzten Ressourcen zugreifen kann. 3.. Verwenden Sie Defer entsperr (), um sicherzustellen, dass das Schloss immer freigegeben wird, um Deadlocks zu vermeiden. 4. verkürzen die Vorg?nge im kritischen Bereich so weit wie m?glich, um die Leistung zu verbessern; 5. Für Szenarien, in denen mehr Lese- und Weniger -Schreibvorg?nge, sollte Sync.rwmutex verwendet werden, um Operationen über Rlock ()/Runlock () zu lesen und Operationen über Lock ()/Unlock () zu schreiben, um die Effizienz der Parallelseffizienz zu verbessern.

Wenn Sie einen kritischen Codeabschnitt in GO schützen müssen, ist mit den Methoden Lock() und Unlock() vor dem sync.Mutex -Typ der Standardansatz. Diese Methoden tragen dazu bei, dass nur eine Goroutine zu einem bestimmten Zeitpunkt auf den geschützten Abschnitt zugreifen kann und die Rassenbedingungen verhindert.

Was ist ein Mutex in Go?

Go's sync.Mutex ist ein gegenseitiges Ausschlussschloss, mit dem der Zugriff auf gemeinsame Ressourcen über mehrere Goroutinen hinweg synchronisiert wird. Wenn ein Goroutine Lock() anruft, blockiert es, bis der Mutex verfügbar ist, wenn er bereits von einer anderen Goroutine gesperrt ist. Sobald es mit dem kritischen Abschnitt fertig ist, wird das Aufrufen Unlock() das Schloss ver?ffentlicht, damit andere fortfahren k?nnen.

Hier erfahren Sie, wie Sie einen Mutex deklarieren und verwenden:

 var mu sync.mutex

Sie haben diesen Mutex in der Regel neben den von ihm geschützten Daten eingebettet. Es ist üblich, dieses Muster bei der Arbeit mit Strukturen oder globalen Variablen zu sehen, die zwischen Goroutinen geteilt werden.

So verwenden Sie lock () und entsperren () richtig

Das Wichtigste ist, Unlock() nach Abschluss der Arbeit im kritischen Abschnitt immer anzurufen - auch wenn ein Fehler auftritt. Eine g?ngige Praxis besteht darin defer mu.Unlock() gleich nach dem Aufrufen mu.Lock() zu verwenden.

Hier ist ein grundlegendes Beispiel:

 Paket Main

importieren (
    "fmt"
    "Synchronisation"
)

var (
    Z?hler = 0
    mu sync.mutex
)

Funcy Increment (wg *sync.waitgroup) {
    aufschieben wg.done ()
    mu.lock ()
    aufschieben mu.unlock ()
    Schalter  
}

func main () {
    var wg sync.waitgroup
    für i: = 0; i <1000; ich {
        wg.add (1)
        Gehen Sie inkrement (& wg)
    }
    wg.wait ()
    fmt.println ("endgültiger Z?hler:", Z?hler)
}

In diesem Beispiel:

• Mehrere Goroutinen versuchen, einen gemeinsam genutzten Z?hler zu erh?hen.
• Die mu.Lock() sorgt dafür, dass nur eine Goroutine jeweils in den kritischen Abschnitt eingeben kann.
• defer mu.Unlock() garantiert, dass das Schloss freigegeben wird, auch wenn im Block etwas schief geht.

Einige wichtige Punkte:

• Passen Sie immer Lock() und Unlock() zusammen.
• Bevorzugt Unlock() unmittelbar nach dem Sperren.
• Vermeiden Sie langlebige Operationen in einem verschlossenen Abschnitt-halten Sie kritische Abschnitte so kurz wie m?glich.

H?ufige Fehler zu vermeiden

Sogar erfahrene Entwickler machen manchmal Fehler beim Verwalten von Schl?sser. Hier sind ein paar Fallstricke, auf die Sie achten müssen:

• Vergessen zu entsperren : Dies führt zu Deadlocks. Wenn eine Goroutine sperrt, aber niemals freigeschaltet ist, werden andere Goroutinen, die auf demselben Schloss warten, für immer festsitzen.
• Doppelsperrung denselben Mutex : Aufrufen von Lock() erneut auf demselben Mutex, ohne zu entsperren, verursacht zuerst einen Deadlock.
• Kopieren eines gesperrten Mutex : GO entmutigt das Kopieren von Werten von Typen, die Mutexes enthalten. Dies kann die Synchronisationslogik lautlos durchbrechen.

Um diese Probleme zu verhindern:

• Verwenden Sie defer mu.Unlock() wann immer m?glich.
• Seien Sie vorsichtig, wenn Sie Strukturen, die Mutexes enthalten, anstelle von Wert an Zeiger passieren.
• Erw?gen Sie, Tools wie -race -Flag ( go run -race ) zu verwenden, um die Rennbedingungen w?hrend des Tests zu erkennen.

Wann soll RWMutex stattdessen verwendet werden

Wenn Ihre Bewerbung mehr gelesene Operationen als Schreibvorg?nge hat, sollten Sie sync.RWMutex verwenden. Es erm?glicht mehreren Lesern, bietet jedoch einen exklusiven Zugriff auf einen einzelnen Schriftsteller.

• Verwenden Sie RLock() / RUnlock() zum Lesen.
• Verwenden Sie beim Schreiben Lock() / Unlock() .

Dies kann die Leistung in les-hungrigen Szenarien erheblich verbessern. Aber denken Sie daran: Ein Schreibschlossbl?cke alle Lesungen und ein Lesesperrbl?cke schreibt.

Also in F?llen, in denen:

• Sie haben viele gleichzeitige Leser,
• Schreiben sind selten,

... Die Verwendung von RWMutex kann besser passen als ein normaler Mutex .

Grunds?tzlich ist das.

Das obige ist der detaillierte Inhalt vonWie verwende ich die Methoden lock () und entsplock (), um einen kritischen Codeabschnitt in Go zu schützen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!