Golang 借助 Mutex 构建可重入锁

在 Go 语言的并发编程中，Mutex（互斥锁）是一种常用的同步机制。然而，标准的 Mutex 并不支持可重入特性。在某些复杂的场景下，我们可能需要构建可重入锁来满足特定的需求。

可重入锁是指在同一个线程中，已经获取到锁的情况下，可以再次获取该锁而不会导致死锁。这在一些递归函数或者嵌套调用的场景中非常有用。

我们来定义一个可重入锁的结构体。

type ReentrantMutex struct {
    lock    sync.Mutex
    owner   int
    recursion int
}

在这个结构体中，lock 是标准的 Mutex，owner 用于记录持有锁的线程 ID，recursion 用于记录获取锁的递归次数。

接下来，实现 Lock 方法。

func (rm *ReentrantMutex) Lock() {
    currentGoroutineID := getGoroutineID()
    if rm.owner == currentGoroutineID {
        rm.recursion++
        return
    }
    rm.lock.Lock()
    rm.owner = currentGoroutineID
    rm.recursion = 1
}

在 Lock 方法中，通过获取当前线程的 ID 与已记录的所有者 ID 进行比较。如果是同一个线程，则增加递归次数；否则，通过标准 Mutex 进行加锁，并设置所有者和递归次数。

然后，实现 Unlock 方法。

func (rm *ReentrantMutex) Unlock() {
    currentGoroutineID := getGoroutineID()
    if rm.owner!= currentGoroutineID {
        panic("unlock from a different goroutine")
    }
    if rm.recursion > 1 {
        rm.recursion--
        return
    }
    rm.lock.Unlock()
    rm.owner = 0
    rm.recursion = 0
}

在 Unlock 方法中，先检查是否是当前线程在解锁。如果是，且递归次数大于 1，则减少递归次数；否则，通过标准 Mutex 解锁，并重置所有者和递归次数。

通过以上的实现，我们成功地在 Go 语言中借助 Mutex 构建了一个可重入锁。在实际应用中，使用可重入锁可以避免一些由于不可重入导致的死锁和错误，提高程序的并发安全性和稳定性。

需要注意的是，在多线程编程中，锁的使用要谨慎，过度使用或者使用不当都可能导致性能下降或者其他并发问题。在编写代码时，要充分考虑锁的粒度、持有时间以及可能的竞争情况，以确保程序的高效和正确运行。