Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go语言 Mutex互斥锁

一文掌握Go语言并发编程必备的Mutex互斥锁

作者：金刀大菜牙

Go 语言提供了 sync 包，其中包括 Mutex 互斥锁、RWMutex 读写锁等同步机制，本篇博客将着重介绍 Mutex 互斥锁的基本原理，需要的可以参考一下

在并发编程中，我们需要处理多个线程同时对共享资源的访问问题。如果不加控制地同时访问共享资源，就会导致竞争条件（Race Condition）问题，从而导致程序出现不可预知的错误。为了解决这个问题，Go 语言提供了 sync 包，其中包括 Mutex 互斥锁、RWMutex 读写锁等同步机制，本篇博客将着重介绍 Mutex 互斥锁的基本原理。

1. Mutex 互斥锁的基本概念

Mutex 是 Mutual Exclusion（互斥）的缩写，用于保护共享资源。当一个goroutine 获取了 Mutex 的锁之后，其他的 goroutine 就无法再获取到这个 Mutex 的锁，直到这个 goroutine 释放了这个 Mutex 的锁，其他 goroutine 才能继续尝试获取这个 Mutex 的锁。

Mutex 互斥锁包含两个状态：锁定和未锁定。当一个 goroutine 获取了 Mutex 的锁，Mutex 就处于锁定状态，其他的 goroutine 就只能等待这个 goroutine 释放这个 Mutex 的锁，才能再次尝试获取这个 Mutex 的锁。当一个 goroutine 释放了 Mutex 的锁，Mutex 就处于未锁定状态，此时其他的 goroutine 可以获取这个 Mutex 的锁。

Mutex 互斥锁使用的是二进制信号量的概念，当 Mutex 处于锁定状态时，就相当于信号量为 0，其他 goroutine 只能等待；当 Mutex 处于未锁定状态时，就相当于信号量为 1，其他 goroutine 可以尝试获取这个 Mutex 的锁。

2. Mutex 互斥锁的基本用法

Mutex 互斥锁的基本用法如下：

package main
​
import (
    "fmt"
    "sync"
    "time"
)
​
func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    var count int
​
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            defer mu.Unlock()
            count++
            fmt.Println(count)
            time.Sleep(time.Millisecond)
            wg.Done()
        }()
    }
​
    wg.Wait()
}

在上面的例子中，我们创建了 10 个 goroutine，每个 goroutine 都会获取 Mutex 的锁，对共享变量 count 进行自增操作，并打印 count 的值。在获取 Mutex 的锁后，我们使用 defer 语句来保证在 goroutine 结束时释放 Mutex 的锁。最后，我们使用 WaitGroup 来等待所有 goroutine 结束。

由于 Mutex 互斥锁是排他性的，因此在同一时刻只有一个 goroutine 可以获取 Mutex 的锁，其他的 goroutine 只能等待。在上面的例子中，我们通过 Mutex 互斥锁来保证了 count 的原子性操作，从而避免了竞争条件问题。

3. Mutex 互斥锁的底层实现

Mutex 互斥锁的底层实现使用了操作系统提供的原语（Primitive），如互斥量（Mutex）、临界区（Critical Section）等。在不同的操作系统中，Mutex 互斥锁的底层实现可能有所不同。

在 Linux 系统中，Mutex 互斥锁的底层实现主要使用了 futex（Fast User-space Mutex）机制。futex 是 Linux 系统提供的一种快速用户空间互斥量机制，可以实现用户空间的原子操作。

Mutex 互斥锁的底层实现主要包括两个部分：等待队列和锁状态。

3.1 等待队列

当一个 goroutine 尝试获取 Mutex 的锁时，如果 Mutex 已经被其他 goroutine 获取，那么这个 goroutine 就会进入等待队列中等待。等待队列是一个链表，每个节点代表一个等待 goroutine。

当一个 goroutine 释放 Mutex 的锁时，会唤醒等待队列中的第一个 goroutine。唤醒的操作主要包括两个步骤：

3.2 锁状态

Mutex 互斥锁的锁状态主要包括两个部分：互斥标志和持有者标志。

互斥标志表示 Mutex 的状态，0 表示未锁定，1 表示锁定。互斥标志的原子操作主要使用了 Compare-and-Swap（CAS）指令。

持有者标志表示当前持有 Mutex 的 goroutine 的 ID。如果 Mutex 未被任何 goroutine 持有，那么持有者标志为 0。持有者标志的原子操作主要使用了 Load Linked（LL）和 Store Conditional（SC）指令。

当一个 goroutine 尝试获取 Mutex 的锁时，会先尝试使用 CAS 指令将互斥标志从 0 改为 1。如果 CAS 指令成功，那么这个 goroutine 就获得了 Mutex 的锁，并将持有者标志设置为当前 goroutine 的 ID。如果 CAS 指令失败，那么说明 Mutex 已经被其他 goroutine 获取，这个 goroutine 就会进入等待队列中等待。

当一个 goroutine 释放 Mutex 的锁时，会先将持有者标志设置为 0，然后再使用 LL 和 SC 指令将互斥标志从 1 改为 0。LL 指令用于加载互斥标志的值，SC 指令用于将互斥标志的值改为 0。LL 和 SC 指令是原子指令，可以保证操作的原子性。

4. Mutex 互斥锁的注意事项

在使用 Mutex 互斥锁时，需要注意以下几点：

4.1 不要将 Mutex 作为函数或方法的参数传递

Mutex 是一个结构体类型，包含互斥标志和持有者标志等字段。当将 Mutex 作为函数或方法的参数传递时，会将 Mutex 的副本传递给函数或方法，而不是原始的 Mutex 实例。这样做会导致不同的 goroutine 使用不同的 Mutex 实例，从而无法实现互斥。

正确的做法是将 Mutex 定义为一个全局变量，并在多个 goroutine 中共享这个全局变量。

4.2 不要在获取 Mutex 的锁时阻塞太久

当一个 goroutine 尝试获取 Mutex 的锁时，如果 Mutex 已经被其他 goroutine 获取，那么这个 goroutine 就会进入等待队列中等待。如果等待时间过长，会导致性能下降。

可以使用 TryLock() 方法尝试获取 Mutex 的锁。TryLock() 方法会立即返回，如果获取锁成功返回 true，否则返回 false。

4.3 不要重复释放 Mutex 的锁

当一个 goroutine 释放 Mutex 的锁时，如果这个 goroutine 不是 Mutex 的持有者，那么会导致 panic 异常。因此，在释放 Mutex 的锁时，需要确保当前 goroutine 是 Mutex 的持有者。

可以使用 defer 语句在获取 Mutex 的锁时自动注册释放锁的操作，以确保在任何情况下都能正确释放 Mutex 的锁。

4.4 不要在锁内部执行阻塞或耗时操作

当一个 goroutine 持有 Mutex 的锁时，其他 goroutine 无法获取 Mutex 的锁，从而会导致阻塞。如果在 Mutex 的锁内部执行阻塞或耗时操作，会导致其他 goroutine 长时间等待，从而影响性能。

可以将阻塞或耗时操作放到 Mutex 的锁外部执行，以避免阻塞其他 goroutine。

5. 总结

本文介绍了 Go 语言中的 Mutex 互斥锁，包括 Mutex 的基本用法、互斥锁的底层实现和注意事项。Mutex 是 Go 语言中实现互斥的重要工具，可以保证多个 goroutine 之间的数据访问安全。

在使用 Mutex 时，需要注意避免一些常见的错误，如将 Mutex 作为函数或方法的参数传递、在获取 Mutex 的锁时阻塞太久、重复释放 Mutex 的锁、在锁内部执行阻塞或耗时操作等。

除了 Mutex 互斥锁，Go 语言还提供了其他类型的锁，如读写锁（sync.RWMutex）、条件变量（sync.Cond）等，可以根据不同的场景选择不同类型的锁。

最后，希望你能够通过本文对 Mutex 互斥锁有一个更深的理解。

到此这篇关于一文掌握Go语言并发编程必备的Mutex互斥锁的文章就介绍到这了,更多相关Go语言 Mutex互斥锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文