Was führt dazu, dass meine Goroutine im folgenden Mutex-Code hängen bleibt?

PHP-Editor Wettbewerb um gemeinsame Ressourcen. Wenn jedoch Probleme im Code auftreten, kann dies dazu führen, dass die Goroutine blockiert und die Ausführung nicht fortgesetzt werden kann. Als nächstes werden wir die möglichen Ursachen dieses Problems im Detail besprechen und Lösungen anbieten.

Frageninhalt

Ich versuche eine Schlüsselkarte zu speichern, jeder Schlüssel hat ein separates Schloss. Beim Erstellen einer Sperre für einen bestimmten Schlüssel verwende ich einen globalen Mutex, um in die Karte zu schreiben.

Nachdem ich das Schloss für den Schlüssel fertig erstellt habe, werde ich das neue Schloss verwenden und es freigeben, wenn die Arbeit erledigt ist. Derzeit versuche ich, einen einzelnen Schlüssel zu ändern, um meinen Code zu testen.

Das ist der Code:

// You can edit this code!
// Click here and start typing.
package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var globalMutex *sync.RWMutex
var mutexes map[int]*sync.Mutex

func MyLock(index int) {
    fmt.Println("Aquiring Lock")
    globalMutex.Lock()
    defer globalMutex.Unlock()

    count++

    if mutexes == nil {
        mutexes = make(map[int]*sync.Mutex)
    }

    if _, ok := mutexes[index]; !ok {
        mutexes[index] = &sync.Mutex{}
    }

    fmt.Println("Aquiring 2nd Lock")
    mutexes[index].Lock()
    fmt.Println("Aquired Lock")
}

func MyUnlock(index int) {
    globalMutex.Lock()
    defer globalMutex.Unlock()
    mutexes[index].Unlock()
}

func main() {
    var wg sync.WaitGroup
    globalMutex = &sync.RWMutex{}
    wg.Add(500)
    for i := 0; i < 500; i++ {
        go func(i int) {
            defer wg.Done()

            MyLock(2)

            time.Sleep(1 * time.Second)
            fmt.Println(i)

            MyUnlock(2)
        }(i)
    }

    wg.Wait()
    fmt.Println(mutexes)
    fmt.Println(count)
}

Ich bin mir nicht sicher, warum die Sperre nicht aktiviert werden kann. Spielplatz-Link: https://go.dev/play/p/-co0xaxpuy0

Solution

mylock kann globale Mutexe und einzelne Mutexe sperren. Dies macht das Entsperren in manchen Fällen unmöglich:

1. goroutine 1 ruft mylock(2) auf. Dadurch wird die einzelne Sperre l2 wie erwartet gesperrt.
2. goroutine 2 ruft mylock(2) auf. Es erhält die globale Sperre und blockiert dann, bis l2 freigegeben wird. Während des Wartens bleibt die globale Sperre bestehen.
3. goroutine 1 ruft myunlock(2) auf. Es ist blockiert und wartet darauf, dass die globale Sperre (gehalten von Goroutine 2) aufgehoben wird. Das ist eine Sackgasse.

Um dies zu beheben, geben Sie die einzelnen Sperren zurück, während Sie die globale Sperre beibehalten, anstatt sie zu (ent)sperren. myunlock-Funktion wird überflüssig: ​​

func mylock(index int) *sync.mutex {
    globalmutex.lock()
    defer globalmutex.unlock()

    count++

    if mutexes == nil {
        mutexes = make(map[int]*sync.mutex)
    }

    mu := mutexes[index]
    if mu == nil {
        mu = &sync.mutex{}
        mutexes[index] = mu
    }

    return mu
}

func main() {
    var wg sync.waitgroup
    globalmutex = &sync.rwmutex{}
    wg.add(500)
    for i := 0; i < 500; i++ {
        go func(i int) {
            defer wg.done()

            mu := mylock(2)
            mu.lock()
            defer mu.unlock()

            time.sleep(1 * time.second)
            fmt.println(i)
        }(i)
    }

    wg.wait()
    fmt.println(mutexes)
    fmt.println(count)
}

Um die Leistung zu verbessern, können Sie zunächst prüfen, ob eine einzelne Sperre vorhanden ist, während Sie nur eine globale Lesesperre halten (beachten Sie, dass sich dadurch ändert, was count darstellt):

func MyLock(index int) *sync.Mutex {
    globalMutex.RLock()
    mu := mutexes[index]
    globalMutex.RUnlock()

    if mu != nil {
        return mu
    }
    
    globalMutex.Lock()
    defer globalMutex.Unlock()

    count++

    if mutexes == nil {
        mutexes = make(map[int]*sync.Mutex)
    }

    mu = mutexes[index] // have to check again because
    if mu == nil {      // we briefly released globalMutex 
        mu = &sync.Mutex{}
        mutexes[index] = mu
    }

    return mu
}

Das obige ist der detaillierte Inhalt vonWas führt dazu, dass meine Goroutine im folgenden Mutex-Code hängen bleibt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!