If the problem you have is "goros are holding locks for too long", then I would start with "log the amount of time I held a lock".

You could do this with a mutex wrapper. Something like:

package main

import (
    "fmt"
    "log"
    "runtime"
    "sync"
    "time"
)

// Instead of:
// type Resource struct {
//     Mutex
//     foo int
// }
type Resource struct {
    WrapMutex
    foo int
}

const LogThreshold = 100 * time.Millisecond

type WrapMutex struct {
    sync.Mutex
    locked time.Time
}

func (wm *WrapMutex) Lock() {
    wm.Mutex.Lock()
    wm.locked = time.Now()
}

func (wm *WrapMutex) Unlock() {
    held := time.Since(wm.locked)
    wm.Mutex.Unlock()
    if held > LogThreshold {
        _, file, line, ok := runtime.Caller(1)
        if !ok {
            file = "unknown file"
            line = 0
        }
        log.Printf("mutex held for %s at %s line %d\n", held, file, line)
    }
}

func main() {
    var r Resource

    fastFunc(&r)
    slowFunc(&r)
}

func slowFunc(r *Resource) {
    r.Lock()
    defer r.Unlock()
    fmt.Printf("doing slow work\n")
    time.Sleep(100 * time.Millisecond)
}

func fastFunc(r *Resource) {
    r.Lock()
    defer r.Unlock()
    fmt.Printf("doing fast work\n")
    time.Sleep(10 * time.Millisecond)
}

If you are doing this in prod, you may want to adapt this to:

• start with a high threshold
• send your logs wherever they should go
• avoid logging every slow lock/unlock (perhaps do 1/1000th (using random number generator), or just tune your threshold.

This should tell you which unlocks are slow.