Wie können Mutex-Sperren verwendet werden, um einen gegenseitigen Ausschluss in gleichzeitigen Goroutinen zu erreichen?

Gegenseitiger Ausschluss gleichzeitiger Goroutinen mit Mutex-Sperren

In Ihrem Code möchten Sie sicherstellen, dass bestimmte Codeabschnitte in jeder Goroutine isoliert ausgeführt werden . Dies verhindert die gleichzeitige Ausführung dieser Abschnitte durch andere Goroutinen. So kann ein gegenseitiger Ausschluss mithilfe von Mutex-Sperren erreicht werden:

Die bereitgestellte Codeübersicht zeigt den Ablauf von Goroutinen und die Notwendigkeit des gegenseitigen Ausschlusses. Sie möchten verhindern, dass die Ausführung an andere Goroutinen weitergegeben wird, während bestimmte Ereignisse in einer Goroutine ausgeführt werden.

Um dies zu implementieren, kann eine Mutex-Sperre verwendet werden. Ein Mutex stellt sicher, dass jeweils nur eine Goroutine auf eine gemeinsam genutzte Ressource zugreifen kann. Hier ist eine leicht modifizierte Version Ihres Codes, die Mutexe für den gegenseitigen Ausschluss verwendet:

<code class="go">package main

import (
    "fmt"
    "rand"
    "sync"
)

var (
    mutex1, mutex2, mutex3 sync.Mutex
    wg sync.WaitGroup
)

func Routine1() {
    mutex1.Lock()
    // Do something
    for i := 0; i < 200; i++ {
        mutex2.Lock()
        mutex3.Lock()
        fmt.Println("Value of z")
        mutex2.Unlock()
        mutex3.Unlock()
    }
    // Do something
    mutex1.Unlock()
    wg.Done()
}

func Routine2() {
    mutex2.Lock()
    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex3.Lock()
        fmt.Println("Value of z")
        mutex1.Unlock()
        mutex3.Unlock()
    }
    // Do something
    mutex2.Unlock()
    wg.Done()
}

func Routine3() {
    mutex3.Lock()
    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex2.Lock()
        fmt.Println("Value of z")
        mutex1.Unlock()
        mutex2.Unlock()
    }
    // Do something
    mutex3.Unlock()
    wg.Done()
}

func main() {
    wg.Add(3)
    go Routine1()
    go Routine2()
    Routine3()
    wg.Wait()
}</code>

So erreicht dieser aktualisierte Code den gegenseitigen Ausschluss:

1. Für jede Goroutine wird eine Mutex-Sperre erstellt (Mutex1, Mutex2 und Mutex3).
2. Wenn eine Goroutine auf den kritischen Abschnitt zugreifen muss (wo gegenseitiger Ausschluss erforderlich ist), sperrt sie den entsprechenden Mutex.
3. Während der Mutex durch gesperrt ist Eine Goroutine, andere Goroutinen, die versuchen, auf denselben Mutex zuzugreifen, werden blockiert, bis er entsperrt wird.
4. Sobald der kritische Abschnitt abgeschlossen ist, entsperrt die Goroutine den Mutex und ermöglicht anderen Goroutinen den Zugriff darauf.

Diese Implementierung stellt sicher, dass die angegebenen Codeabschnitte in jeder Goroutine isoliert ausgeführt werden, wodurch die gleichzeitige Ausführung durch andere Goroutinen verhindert wird.

Das obige ist der detaillierte Inhalt vonWie können Mutex-Sperren verwendet werden, um einen gegenseitigen Ausschluss in gleichzeitigen Goroutinen zu erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!