What is causing my goroutines to deadlock in the following mutex code?

I am trying to keep a map of keys with separate locks for each key.
While creating the lock for a specific key, I'm using a global mutex to write to the map.

After it is done creating the lock for a key, I'm using the new lock and releasing after I'm done with my job.
Currently I'm trying to modify a single key only to test my code.

Here is the 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)
}

I'm not sure why it is failing to acquire lock.
Playground link: https://go.dev/play/p/-CO0xaXPuy0

I'm not entirely sure what you are trying to do with this, but ...

Your print statements tell the story. MyUnlock tries to lock the global mutex while another goroutine still has it locked because it is waiting on the indexed mutex you are about to unlock.

MyLock locks both the global and the individual mutexes. This makes it impossible to unlock in some circumstances:

1. Goroutine 1 calls MyLock(2). This causes the individual lock L2 to be locked, as intended.
2. Goroutine 2 calls MyLock(2). It acquires the global lock and is then blocked waiting for L2 to be released. While it is waiting, the global lock continues to be held.
3. Goroutine 1 calls MyUnlock(2). It is blocked waiting for the global lock (held by goroutine 2) to be released. This is the deadlock.

To fix this, return the individual locks instead of (un)locking them while the global lock is held. The MyUnlock function becomes unnecessary:

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

To improve performance, you can check if the individual lock exists first while holding only a global read lock (note that this changes what count represents):

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
}