mutex.Lock() 如何知道要锁定哪些变量？

Question

我是个新手，所以请温柔一点。

所以我已经在我的一些代码中使用互斥体几周了。我理解其背后的概念：锁定对特定资源的访问，与其交互（读或写），然后再次为其他资源解锁。

我使用的互斥锁代码主要是复制粘贴调整。代码运行了，但我仍在尝试了解它的内部工作原理。到目前为止，我一直在结构中使用互斥锁来锁定结构。今天我发现了这个例子，这让我完全不清楚互斥锁实际上锁定了什么。下面是一段示例代码：

var state = make(map[int]int)

var mutex = &sync.Mutex{}

var readOps uint64
var writeOps uint64

// Here we start 100 goroutines to execute repeated reads against the state, once per millisecond in each goroutine.
for r := 0; r < 100; r++ {
    go func() {
        total := 0
        for {
            key := rand.Intn(5)
            mutex.Lock()
            total += state[key]
            mutex.Unlock()
            atomic.AddUint64(&readOps, 1)

            time.Sleep(time.Millisecond)
        }
    }()
}

令我困惑的是，互斥体和它应该锁定的值之间似乎没有任何联系。直到今天，我还认为互斥锁可以锁定特定变量，但看看这段代码，似乎以某种方式将整个程序锁定为仅执行锁定下方的行，直到再次运行解锁。我想这意味着所有其他 goroutine 都会暂停一会儿，直到再次运行解锁。由于代码已编译，我想它可以知道

lock()

和

unlock()

之间访问了哪些变量，但我不确定是否是这种情况。

如果所有其他程序暂停一会儿，这听起来不像真正的多处理，所以我猜我对发生的事情没有很好的理解。

有人可以帮我理解计算机如何知道应该锁定哪些变量吗？

Answer 1

锁定对特定资源的访问，与其交互（读或写），然后再次为其他资源解锁。

基本上是的。

令我困惑的是，互斥体和它应该锁定的值之间似乎没有任何联系。

Mutex 只是一个互斥对象，用于同步对资源的访问。这意味着，如果两个不同的 goroutine 想要锁定互斥锁，则只有第一个 goroutine 可以访问它。第二个 goroutine 现在无限期地等待，直到它自己可以锁定互斥锁。与变量没有任何联系，您可以根据需要使用互斥体。例如只有一个http请求，只有一个数据库读/写操作或者只有一个变量赋值。虽然我不建议在这些示例中使用互斥体，但总体思路应该变得清晰。

但是看看这段代码，它似乎以某种方式将整个程序锁定为仅执行锁定下方的行，直到再次运行解锁。

不是整个程序，只有每个想要访问相同互斥量的 Goroutine 会等待，直到它可以。

我想这意味着所有其他 goroutine 都会暂停一会儿，直到再次运行解锁。

不，他们不会停下来。他们执行直到想要访问相同的互斥体为止。

如果您想使用变量专门对互斥体进行分组，为什么不创建一个结构体？

Answer 2

事实上，互斥锁并不锁定变量或数据，而是锁定代码区域（位于 Lock() 和 Unlock() 函数调用之间）。互斥体不会阻止多个 goroutine 同时访问相同的数据，但会同时运行相同的代码段。 互斥锁不关心变量、数据或内存位置...

互斥体通常包含一个变量来指示互斥体是否被锁定。为了简化，您可以将其想象为一个可以有两个值的整数：

• 0：互斥体被锁定。除了锁定它的 Goroutine 之外，任何 Goroutine 都不允许运行受互斥体保护的代码段
• 1：互斥量被解锁，并且每个goroutine都可以锁定互斥量并运行受保护的代码段。

当 Goroutine 想要运行受解锁互斥锁保护的代码段时，状态会自动从 1 切换到 0。一旦 goroutine 完成，互斥锁就会解锁，状态会自动从 0 切换到 1。

让我们看一个例子：

mapp := make(map[int]int)

func funcA () {
  var mutexA sync.Mutex
  mutexA.Lock()
  for i := 1; i < 1000; i++ {
    mapp[i] = i
  }
  mutexA.Unlock()
}

func funcB () {
 var mutexB sync.Mutex
 mutexB.Lock()
 for i := 1; i < 1000; i++ {
    mapp[i] = i + 1
 }
 mutexB.Unlock()
}

go funcA()
go funcB()

此代码不受数据竞争保护，因为 mapp 映射变量可以同时由 2 个不同的 goroutine 编辑，因为它们都有 2 个不同的互斥体保护 2 个不同的代码部分。 mutexA 仅保护 funcA 函数的关键代码部分，而 mutexB 仅保护 funcB 函数的关键代码部分。

我们有 2 个 goroutine 处理相同的数据，但通过 2 个不同的函数。如何解决这个问题？

通过在两个 goroutine 中使用相同的互斥锁：

mapp := make(map[int]int)
var commonMutex sync.Mutex

func funcA () { 
  commonMutex.Lock()
  for i := 1; i < 1000; i++ {
    mapp[i] = i
  }
  commonMutex.Unlock()
}

func funcB () {
 commonMutex.Lock()
 for i := 1; i < 1000; i++ {
    mapp[i] = i + 1
 }
 commonMutex.Unlock()
}

go funcA()
go funcB()

当互斥锁被锁定时，它保护的所有代码段（Lock()和Unlock()之间）也被锁定。 现在，当 goroutine A 锁定 commonMutex 互斥量时，goroutine B 在 goroutine A 解锁并反转之前无法进入 funcB 的 for 循环。

这就是为什么互斥锁经常被声明为结构体字段。它允许在多个功能中保护相同的数据。