Wie können WaitGroups und Mutexes verwendet werden, um einen gegenseitigen Ausschluss zwischen gleichzeitigen Goroutinen in Go zu erreichen?

Gegenseitiger Ausschluss gleichzeitiger Goroutinen mithilfe von WaitGroup und Mutexes

Um den gegenseitigen Ausschluss gleichzeitiger Goroutinen in Go zu erreichen, wo jeweils nur eine Goroutine vorhanden ist Wenn wir bestimmten Code ausführen können, können wir eine Kombination aus WaitGroup und Mutexes nutzen.

WaitGroup ist ein Synchronisierungsprimitiv, das es uns ermöglicht, zu warten, bis eine Gruppe von Goroutinen ihre Ausführung abgeschlossen hat, bevor wir fortfahren. Mutexe hingegen bieten einen gegenseitigen Ausschluss-Sperrmechanismus, der sicherstellt, dass ein kritischer Codeabschnitt nicht von mehreren Goroutinen gleichzeitig ausgeführt wird.

Betrachten Sie den folgenden Beispielcode:

<code class="go">package main

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

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

func Routine1() {
    mutex1.Lock()
    defer mutex1.Unlock() // Ensure mutex is always unlocked before returning
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex2.Lock()
        defer mutex2.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine2() {
    mutex2.Lock()
    defer mutex2.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine3() {
    mutex3.Lock()
    defer mutex3.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex2.Lock()
        defer mutex2.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func main() {
    wg.Add(3)
    go Routine1()
    go Routine2()
    Routine3()
    wg.Wait() // Wait for all goroutines to complete
}</code>

In diesem Code haben wir drei separate Goroutinen (Routine1, Routine2 und Routine3), die alle bestimmte Vorgänge gleichzeitig ausführen. Wir möchten jedoch sicherstellen, dass bestimmte Abschnitte des Codes (die Sende- und Druckereignisse) ohne Beeinträchtigung durch andere Goroutinen ausgeführt werden.

Dies erreichen wir durch die Verwendung von Mutexes. Wir definieren drei Mutexe (Mutex1, Mutex2 und Mutex3) und erwerben die Sperre für den entsprechenden Mutex, bevor wir den kritischen Abschnitt ausführen. Wenn ein Mutex von einer Goroutine gesperrt wird, werden andere Goroutinen, die versuchen, dieselbe Sperre zu erlangen, blockiert, bis sie verfügbar wird.

Durch das Sperren und Entsperren der entsprechenden Mutexe stellen wir sicher, dass nur eine Goroutine den kritischen Abschnitt ausführen kann zu jeder Zeit. Dies verhindert die gleichzeitige Ausführung dieser Codeabschnitte und gewährleistet den gegenseitigen Ausschluss zwischen den Goroutinen.

Schließlich verwenden wir eine WaitGroup, um sicherzustellen, dass die Hauptfunktion nicht beendet wird, bis alle drei Goroutinen ihre Ausführung abgeschlossen haben. Dadurch können wir die Goroutinen synchronisieren und den Programmablauf steuern.

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