Coroutinen werden zum Erstellen und Wechseln von Lightweight-Threads verwendet, während Sperren zum Synchronisieren des Zugriffs auf gemeinsam genutzte Daten verwendet werden. Die Hauptmethode, mit der Coroutinen mit Sperren interagieren, besteht darin, Sperren zum Schutz kritischer Abschnitte zu verwenden, bei denen es sich um Teile gemeinsamer Daten handelt, auf die mehrere Coroutinen zugreifen. Sie können eine Mutex-Sperre verwenden, um jeweils nur einer Coroutine den Zugriff auf den kritischen Abschnitt zu ermöglichen, oder eine Lese-/Schreibsperre, um mehreren Coroutinen gleichzeitig das Lesen des kritischen Abschnitts, aber nur einer Coroutine das Schreiben zu ermöglichen. In der Praxis können Sperren verwendet werden, um den gleichzeitigen Zugriff auf den Serverstatus des Webservers und Aktualisierungsvorgänge von Datenbankzeilendaten zu schützen.
Coroutinen
Coroutinen sind leichtgewichtige Threads, der Aufwand für die Erstellung und den Wechsel von Coroutinen ist sehr gering. In Go werden Coroutinen mit dem Schlüsselwort goroutine
erstellt. goroutine
关键字创建。
锁
锁用于同步对共享数据的访问,防止并发访问导致数据不一致。在 Go 中,有以下内置锁:
sync.Mutex
:互斥锁,一次允许一个协程访问临界区。sync.RWMutex
:读写锁,允许多个协程同时读取临界区,但只能有一个协程写入临界区。sync.Once
:一次性锁,确保代码块只执行一次。协程与锁的交互
协程和锁之间最常见的交互是使用锁来保护临界区。临界区是指共享数据被访问的部分代码。
要使用锁保护临界区,需要在临界区前获取锁,并在临界区后释放锁。对于互斥锁和读写锁,可以使用 Lock()
和 Unlock()
方法来获取和释放锁。
import ( "sync" ) var mu sync.Mutex var counter int func incrementCounter() { mu.Lock() counter++ mu.Unlock() }
在上面的示例中,我们将 counter
变量的递增操作放在 incrementCounter
函数中,并使用互斥锁 mu
来保护它。这确保了同一时间只有一个协程可以访问和修改 counter
Sperren
Sperren werden verwendet, um den Zugriff auf freigegebene Daten zu synchronisieren und zu verhindern, dass gleichzeitiger Zugriff zu Dateninkonsistenzen führt. In Go gibt es die folgenden integrierten Sperren:sync.Mutex
: Mutex-Sperre, die es jeweils einer Coroutine ermöglicht, auf den kritischen Abschnitt zuzugreifen. sync.RWMutex
: Lese-/Schreibsperre, die es mehreren Coroutinen ermöglicht, den kritischen Abschnitt gleichzeitig zu lesen, aber nur eine Coroutine kann in den kritischen Abschnitt schreiben. sync.Once
: Einmalige Sperre, um sicherzustellen, dass der Codeblock nur einmal ausgeführt wird. Um eine Sperre zum Schutz eines kritischen Abschnitts zu verwenden, müssen Sie die Sperre vor dem kritischen Abschnitt erwerben und die Sperre nach dem kritischen Abschnitt freigeben. Für Mutex-Sperren und Lese-/Schreibsperren können Sie die Methoden Lock()
und Unlock()
verwenden, um Sperren zu erwerben und freizugeben. rrreee
counter
in die Funktion incrementCounter
ein und verwenden zum Schutz die Mutex-Sperre mu
Es. Dadurch wird sichergestellt, dass jeweils nur eine Coroutine auf die Variable counter
zugreifen und diese ändern kann. 🎜Praxisfall🎜🎜🎜🎜Webserver🎜🎜🎜In einem Webserver können mehrere Coroutinen gleichzeitig verschiedene HTTP-Anfragen bearbeiten. Um zu verhindern, dass mehrere Coroutinen gleichzeitig auf den Serverstatus (z. B. die aktuelle Anzahl von Verbindungen) zugreifen, kann ein Mutex verwendet werden, um den Zugriff auf den Serverstatus zu schützen. 🎜🎜🎜Datenbankzugriff🎜🎜🎜Beim Datenbankzugriff können mehrere Coroutinen gleichzeitig die Datenbank abfragen. Um zu verhindern, dass mehrere Coroutinen gleichzeitig dieselbe Datenzeile aktualisieren, können Lese-/Schreibsperren verwendet werden, um Aktualisierungsvorgänge für Datenbankzeilendaten zu schützen. Lesevorgänge können gleichzeitig ausgeführt werden, während Schreibvorgänge exklusiven Zugriff erfordern. 🎜Das obige ist der detaillierte Inhalt vonInteraktion zwischen Golang-Coroutine und Lock. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!