是什么导致我的 goroutine 在以下互斥体代码中陷入僵局？

PHP小编新一在这里给大家解答一个常见问题：“是什么导致我的Goroutine在以下互斥体代码中陷入僵局？”在并发编程中，使用互斥锁（Mutex）是常见的解决共享资源竞争的方法之一。然而，如果代码中存在一些问题，可能会导致goroutine陷入僵局，无法继续执行。接下来，我们将详细讨论可能导致该问题的原因，并给出解决方案。

问题内容

我试图保存一张钥匙图，每个钥匙都有单独的锁。 在为特定密钥创建锁时，我使用全局互斥体写入映射。

完成为钥匙创建锁后，我将使用新锁并在完成工作后释放。 目前我正在尝试修改单个密钥以测试我的代码。

这是代码：

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

我不确定为什么它无法获取锁。 游乐场链接：https://go.dev/play/p/-co0xaxpuy0

解决方法

mylock 可锁定全局互斥锁和单个互斥锁。这使得在某些情况下无法解锁：

1. goroutine 1 调用 mylock(2)。这会导致单个锁 l2 按预期被锁定。
2. goroutine 2 调用 mylock(2)。它获取全局锁，然后被阻塞等待 l2 被释放。在等待期间，全局锁继续保持。
3. goroutine 1 调用 myunlock(2)。它被阻塞等待全局锁（由 goroutine 2 持有）被释放。这就是僵局。

要解决此问题，请在持有全局锁时返回各个锁，而不是（取消）锁定它们。 myunlock 功能变得不必要：

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

为了提高性能，您可以先检查单个锁是否存在，同时仅持有全局读锁（请注意，这会更改 count 所代表的内容）：

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
}

以上就是是什么导致我的 goroutine 在以下互斥体代码中陷入僵局？的详细内容，更多请关注编程网其它相关文章！