了解互斥体行为

Question

我在想 Go 中的 mutex 会锁定数据，并且不允许任何其他 goroutine 读/写，除非拳头 goroutine 释放锁定。看来我的理解是错误的。阻止其他goroutine 读/写的唯一方法是在其他goroutines 中调用lock。这将确保critical section 被一个且只有一个goroutine 访问。

所以，我预计this 代码会出现死锁：

package main

import(
    "fmt"
    "sync"
)

type myMap struct {
    m map[string]string
    mutex sync.Mutex
}

func main() {
    done := make(chan bool)
    ch := make(chan bool)
    myM := &myMap{
        m:     make(map[string]string),
    }
    go func() {
        myM.mutex.Lock()
        myM.m["x"] = "i"
        fmt.Println("Locked. Won't release the Lock")
        ch <- true
    }()

    go func() {
        <- ch
        fmt.Println("Trying to write to the myMap")
        myM.m["a"] = "b"
        fmt.Println(myM)
        done <- true
    }()
    <- done
}

由于第一个goroutine 锁定了结构，我希望第二个goroutine 无法读取/写入结构，但这里不会发生这种情况。

如果我在第二个goroutine 中添加mux.Lock()，那么就会出现死锁。

我觉得mutex 在 Go 中的工作方式有点奇怪。如果我锁定，那么 Go 不应该允许任何其他 goroutine 读取/写入它。

有人可以向我解释 Go 中的互斥锁概念吗？

Answer 1

互斥体周围没有神奇的力场，可以保护它碰巧嵌入的任何数据结构。如果您锁定了一个互斥体，它会阻止其他代码锁定它，直到它被解锁。不多也不少。 It's well documented in the sync package.

所以在您的代码中，恰好有一个myM.mutex.Lock()，效果与没有互斥锁一样。

正确使用保护数据的互斥锁包括在更新或读取数据之前锁定互斥锁，然后再解锁。通常这段代码会被封装在一个函数中，这样就可以使用 defer：

func doSomething(myM *myMap) {
    myM.mutex.Lock()
    defer myM.mutex.Unlock()
    ... read or update myM
}