Wie kann ich mit WaitGroup einen gegenseitigen Ausschluss in gleichzeitigen Goroutinen erreichen?

Gegenseitiger Ausschluss gleichzeitiger Goroutinen mit WaitGroup

In Ihrem Code haben Sie drei gleichzeitige Goroutinen, die ohne gegenseitige Beeinträchtigung ausgeführt werden müssen bestimmte Abschnitte ihres Codes. Dieses Konzept wird als gegenseitiger Ausschluss bezeichnet und stellt sicher, dass jeweils nur eine Goroutine einen kritischen Codeabschnitt ausführen kann.

Um gegenseitigen Ausschluss mit WaitGroup zu erreichen, können Sie die folgenden Schritte ausführen:

1. Erstellen Sie einen Mutex für jede gleichzeitige Goroutine: Ein Mutex ist ein Sperrmechanismus, der es jeweils nur einer Goroutine ermöglicht, eine Sperre zu erhalten. Erstellen Sie einen separaten Mutex für jede Goroutine, die ausschließlich ihren kritischen Abschnitt ausführen muss.
2. Besorgen Sie sich den Mutex, bevor Sie den kritischen Abschnitt betreten:Bevor Sie den kritischen Codeabschnitt in jeder Goroutine ausführen, rufen Sie auf Lock()-Methode für den entsprechenden Mutex. Dieser Vorgang blockiert die Goroutine, bis der Mutex erfasst wird.
3. Geben Sie den Mutex frei, nachdem Sie den kritischen Abschnitt verlassen haben:Nach Abschluss der Ausführung des kritischen Abschnitts geben Sie den Mutex frei, indem Sie Unlock() aufrufen. Verfahren. Dadurch können andere Goroutinen den Mutex abrufen und in ihre kritischen Abschnitte eintreten.
4. Verwenden Sie WaitGroup, um auf den Abschluss zu warten: Erstellen Sie eine WaitGroup, um den Abschluss aller Goroutinen zu verfolgen. Jede Goroutine sollte nach Abschluss ihrer Ausführung die Done()-Methode der WaitGroup aufrufen. Die Haupt-Goroutine sollte mithilfe der Wait()-Methode der WaitGroup auf den Abschluss aller Goroutinen warten.

Hier ist ein Beispiel, das die oben genannten Schritte implementiert:

<code class="go">package main

import (
    "fmt"
    "sync"
)

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

func Routine1() {
    mutex1.Lock()
    defer mutex1.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex2.Lock()
        mutex3.Lock()
        fmt.Println("value of z")
        mutex2.Unlock()
        mutex3.Unlock()
    }
    // Do something
}

func Routine2() {
    mutex2.Lock()
    defer mutex2.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex3.Lock()
        fmt.Println("value of z")
        mutex1.Unlock()
        mutex3.Unlock()
    }
    // Do something
}

func Routine3() {
    mutex3.Lock()
    defer mutex3.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex2.Lock()
        fmt.Println("value of z")
        mutex1.Unlock()
        mutex2.Unlock()
    }
    // Do something
}

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

In diesem Beispiel , der kritische Abschnitt jeder Goroutine ist die Schleife, in der sie fmt.Println("value of z") ausführt. Die Mutexe stellen sicher, dass jeweils nur eine Goroutine diesen Abschnitt ausführen kann. Die WaitGroup stellt sicher, dass die Haupt-Goroutine auf den Abschluss aller Goroutinen wartet, bevor sie beendet wird.

Das obige ist der detaillierte Inhalt vonWie kann ich mit WaitGroup einen gegenseitigen Ausschluss in gleichzeitigen Goroutinen erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!