Unterstützt die Go-Sprache Sperren?

Go-Sprache unterstützt Sperren. Die Go-Sprachstandardbibliothek bietet zwei Arten von Sperren: 1. Mutex-Sperre (sync.Mutex), die eine Ressource vor Konflikten schützen kann, die durch gleichzeitige Vorgänge verursacht werden und zu ungenauen Daten führen. Wenn die Lesesperre belegt ist, ist das Schreiben blockiert, das Lesen jedoch nicht. In einer Umgebung mit vielen Lesevorgängen und wenigen Schreibvorgängen können zunächst Lese-/Schreibmutexe verwendet werden.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Die Go-Sprachstandardbibliothek bietet zwei Sperren, eine ist eine Mutex-Sperre und die andere ist eine Lese-/Schreibsperre. Das Synchronisierungspaket im Go-Sprachpaket bietet zwei Sperrtypen: Mutex-Sperre (sync.Mutex) und Lese-/Schreibsperre (sync.RWMutex).

Mutex ist die einfachste Art der Sperre und auch relativ gewalttätig. Wenn eine Goroutine einen Mutex erhält, können andere Goroutinen nur warten, bis die Goroutine den Mutex freigibt.

RWMutex ist relativ benutzerfreundlich und ein klassisches Write-Once-Read-Many-Modell. Wenn die Lesesperre belegt ist, wird das Schreiben blockiert, das Lesen jedoch nicht. Das heißt, mehrere Goroutinen können gleichzeitig die Lesesperre erwerben (Aufruf der RLock()-Methode); ()-Methode) verhindert, dass eine andere Goroutine (unabhängig davon, ob sie liest oder schreibt) eingeht. Die gesamte Sperre entspricht dem ausschließlichen Besitz der Goroutine. Der Implementierung von RWMutex nach zu urteilen, kombiniert der RWMutex-Typ tatsächlich Mutex:

type RWMutex struct {
    w Mutex
    writerSem uint32
    readerSem uint32
    readerCount int32
    readerWait int32
}

Für diese beiden Sperrtypen muss jedes Lock() oder RLock() sicherstellen, dass es einen entsprechenden Unlock()- oder RUnlock()-Aufruf gibt, andernfalls This kann dazu führen, dass alle Goroutinen, die auf die Sperre warten, ausgehungert werden oder sogar einen Deadlock verursachen. [Verwandte Empfehlungen: Go-Video-Tutorial, Programmierunterricht] Das typische Verwendungsmuster der

Sperre ist wie folgt:

package main
import (
    "fmt"
    "sync"
)
var (
    // 逻辑中使用的某个变量
    count int
    // 与变量对应的使用互斥锁
    countGuard sync.Mutex
)
func GetCount() int {
    // 锁定
    countGuard.Lock()
    // 在函数退出时解除锁定
    defer countGuard.Unlock()
    return count
}
func SetCount(c int) {
    countGuard.Lock()
    count = c
    countGuard.Unlock()
}
func main() {
    // 可以进行并发安全的设置
    SetCount(1)
    // 可以进行并发安全的获取
    fmt.Println(GetCount())
}

Die Codebeschreibung lautet wie folgt:

• Zeile 10 ist eine Variable, die in a verwendet wird Bestimmter logischer Schritt, unabhängig davon Es spielt keine Rolle, ob es sich um eine Variable auf Paketebene oder ein Strukturmitgliedsfeld handelt.

• Zeile 13: Im Allgemeinen wird empfohlen, die Granularität des Mutex so klein wie möglich einzustellen, um die Wartezeit für den gemeinsamen Zugriff zu verkürzen. Hier benennt der Autor die Mutex-Variable üblicherweise im folgenden Format:

变量名+Guard

, um anzuzeigen, dass der Mutex zum Schutz dieser Variablen verwendet wird.

• Zeile 16 ist eine Funktionskapselung zum Erhalten des Zählwerts. Über diese Funktion kann gleichzeitig und sicher auf die Variablenanzahl zugegriffen werden.

• Zeile 19, versuchen Sie, den countGuard-Mutex zu sperren. Sobald countGuard gesperrt ist und eine andere Goroutine versucht, die Sperre fortzusetzen, wird sie blockiert, bis countGuard entsperrt wird.

• Zeile 22 verwendet „defer“, um den Entsperraufruf von countGuard zu verzögern. Der Entsperrvorgang wird ausgeführt, wenn die Funktion „GetCount()“ zurückkehrt.

• In Zeile 27 wird countGuard beim Festlegen des Zählwerts auch zum Sperren und Entsperren verwendet, um sicherzustellen, dass der Prozess zum Ändern des Zählwerts ein atomarer Prozess ist und keine gleichzeitigen Zugriffskonflikte auftreten.

In einer Umgebung, in der viel gelesen und wenig geschrieben wird, können Sie der Verwendung eines Lese-/Schreib-Mutex (sync.RWMutex) Vorrang einräumen, der effizienter ist als ein Mutex. RWMutex im Sync-Paket bietet eine Kapselung von Lese-/Schreib-Mutexes.

Wir haben einen Teil des Codes im Mutex-Beispiel in einen Lese-/Schreib-Mutex geändert, siehe Code unten:

var (
    // 逻辑中使用的某个变量
    count int
    // 与变量对应的使用互斥锁
    countGuard sync.RWMutex
)
func GetCount() int {
    // 锁定
    countGuard.RLock()
    // 在函数退出时解除锁定
    defer countGuard.RUnlock()
    return count
}

Die Codebeschreibung lautet wie folgt:

• Zeile 6, wenn countGuard deklariert wird, aus sync.Mutex-Mutex Die Sperre wird in die Lese-/Schreib-Mutex-Sperre sync.RWMutex geändert.

• Zeile 12: Der Prozess zum Abrufen der Anzahl ist ein Prozess zum Lesen von Zähldaten, der für Lese- und Schreib-Mutex-Sperren geeignet ist. Ersetzen Sie in dieser Zeile countGuard.Lock() durch countGuard.RLock(), um den Lese-/Schreibmutex als gelesen zu markieren. Wenn eine andere Goroutine gleichzeitig auf countGuard zugreift und gleichzeitig countGuard.RLock() aufruft, erfolgt keine Blockierung.

• Zeile 15, entsprechend der Lesemodussperre, verwenden Sie den Lesemodus zum Entsperren.

Besonderer Hinweis:

• sync.Mutex‘ Sperre kann nicht verschachtelt werden

• sync.RWMutex‘s RLock() kann verschachtelt werden

• sync.RWMutex mu.Lock() kann nicht verschachtelt werden

• mu.Lock() von sync.RWMutex kann nicht in mu.RLock() verschachtelt werden

Weitere Programmierkenntnisse finden Sie unter: Programmiervideo ! !

Das obige ist der detaillierte Inhalt vonUnterstützt die Go-Sprache Sperren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!