Wie kann der gegenseitige Ausschluss in gleichzeitigen Goroutinen mithilfe von Mutexes sichergestellt werden?

Gegenseitiger Ausschluss in gleichzeitigen Goroutinen: Code-Isolierung erreichen

Bei der gleichzeitigen Programmierung ist es wichtig, Mechanismen zu haben, um die Ausführung mehrerer Goroutinen zu verhindern den gleichen Code gleichzeitig. Dies stellt die Datenintegrität sicher und verhindert unerwartetes Verhalten.

Stellen Sie sich das folgende Szenario vor:

<code class="go">Routine 1 {
do something

*Send int to Routine 2
Send int to Routine 3
Print Something
Print Something*

do something
}

Routine 2 {
do something

*Send int to Routine 1
Send int to Routine 3
Print Something
Print Something*

do something
}

Routine 3 {
do something

*Send int to Routine 1
Send int to Routine 2
Print Something
Print Something*

do something
}</code>

Während die Codeabschnitte zwischen Do-Etwas-Markierungen ausgeführt werden, möchten wir verhindern, dass die Kontrolle dorthin fließt andere Goroutinen. Wenn beispielsweise Routine1 den Teil innerhalb der Sterne ausführt, sollten Routine2 und Routine3 blockiert werden.

Gegenseitigen Ausschluss mit WaitGroup erreichen

Ein Ansatz zur Durchsetzung des gegenseitigen Ausschlusses ist Verwenden Sie eine sync.WaitGroup. Diese Technik ist in diesem Szenario jedoch nicht anwendbar, da sie nicht in der Lage ist, Goroutinen selektiv zu blockieren.

Verwendung von Mutexes zur Isolierung

Eine effektivere Lösung ist die Verwendung von Synchronisierung .Mutex. Ein Mutex stellt sicher, dass immer nur eine Goroutine ihn besitzen kann. So implementieren Sie den gegenseitigen Ausschluss mithilfe von Mutexes:

<code class="go">package main

import (
    "fmt"
    "sync"
)

var (
    mutex1, mutex2, mutex3 sync.Mutex
)

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()
}

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()
}

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()
}

func main() {
    go Routine1()
    go Routine2()
    Routine3()
}</code>

In diesem Code:

• Wir definieren einen Mutex für jede Goroutine (Mutex1, Mutex2, Mutex3).
• In jeder Goroutine (Routine1, Routine2, Routine3) sperren wir unseren Mutex am Anfang und entsperren ihn am Ende, um den kritischen Abschnitt darin zu schützen.
• Wenn eine Goroutine versucht, einen bereits vorhandenen Mutex zu sperren Wenn es von einer anderen Goroutine gesperrt wird, wird es blockiert, bis der Mutex verfügbar wird.

Dadurch werden die Druckanweisungen in jeder Goroutine einzeln ausgeführt, um sicherzustellen, dass bis dahin keine anderen Goroutinen auf diese Zeilen zugreifen können Die aktuelle Goroutine hat ihre Sperre freigegeben.

Das obige ist der detaillierte Inhalt vonWie kann der gegenseitige Ausschluss in gleichzeitigen Goroutinen mithilfe von Mutexes sichergestellt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!