Go超时锁的设计和实现

2020-09-03 本文已影响0人筑梦之队

Go提供两种锁：sync.Mutex和sync.RWMutex。

sync.Mutex: 互斥锁。任意时刻，只能有一个方法持有锁，其它方法会被阻塞，直到锁被释放。
sync.RWMutex: 读写锁。任意时刻，只能有一个方法持有写锁，其它方法会被阻塞，直到写锁被释放。但是同一时刻，可以有多个方法持有读锁。

但遗憾的是，无论是sync.Mutex，还是sync.RWMutex，都不支持超时设置。而这是许多应用的重要需求。因为随着项目的功能增多，项目的复杂性也增加，对锁的争夺会变得越来越频繁；尤其是一些访问频繁的数据。

既然官方没有提供，那就只能自己来实现了。到目前为止，我总共实现了三个版本。而版本演变的直接动力，就是我想找到一个简单的模型，同时代码的实现要简单；这样可以避免代码出bug，同时也便于后面的维护。

版本一：

既然不使用官方的锁对象，那最直接的想法就是使用sync/atomic包提供的CompareAndSwapInt32方法来判断，是否成功地获取到了锁。
对于互斥锁，实现的逻辑并不复杂，代码很直观，也很容易维护；但是对于读写锁，实现的代码就很复杂了，非常不利于维护。

locker.go

package syncUtil

import (
    "sync/atomic"
    "time"
)

// 锁对象
type Locker struct {
    value *int32
}

// 尝试加锁，如果在指定的时间内失败，则会返回失败；否则返回成功
// timeout:指定的毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *Locker) Lock(timeout int) bool {
    leftTimeout := timeout
    success := false
    for !success {
        success = atomic.CompareAndSwapInt32(this.value, 0, 1)
        if success {
            break
        }

        if timeout > 0 {
            leftTimeout--
            if leftTimeout == 0 {
                break
            }
        }

        time.Sleep(time.Millisecond)
    }

    return success
}

// 锁定（死等方式）
func (this *Locker) WaitLock() {
    this.Lock(-1)
}

// 解锁
func (this *Locker) Unlock() {
    atomic.CompareAndSwapInt32(this.value, 1, 0)
}

// 创建新的锁对象
func NewLocker() *Locker {
    i := int32(0)
    return &Locker{
        value: &i,
    }
}

rwLocker.go

import (
    "sync/atomic"
    "time"
)

// 读写锁对象
type RWLocker struct {
    read  *int32
    write *int32
}

// 写锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *RWLocker) Lock(timeout int) (success bool) {
    // 写锁优先级更高，所以每次休眠的时间更短，且可以预增加
    interval := 2 * time.Millisecond
    occupied := false
    leftTimeout := timeout

    defer func() {
        // 如果锁失败，且已经预占用了写锁，则将其释放
        if !success && occupied {
            atomic.CompareAndSwapInt32(this.write, 1, 0)
        }
    }()

    for {
        // 如果不是死等，则需要计算超时
        if timeout > 0 {
            // 由于是先扣除时间，所以判断timeout时使用timeout<0，而不是timeout<=0
            leftTimeout--
            if leftTimeout < 0 {
                return
            }
        }

        // 如果写锁没有被占用，则预占用；否则等待下次判断
        if *this.write == 0 {
            // 如果预占用失败，表示被另一个写请求占用；则先休眠，稍后再判断
            if atomic.CompareAndSwapInt32(this.write, 0, 1) == false {
                time.Sleep(interval)
                continue
            } else {
                occupied = true
            }
        } else {
            time.Sleep(interval)
            continue
        }

        // 判断当前的读锁数量是否为0，如果为0表示此次锁定成功，否则需要等待
        if *this.read == 0 {
            success = true
            return
        } else {
            time.Sleep(interval)
        }
    }

    return
}

// 写锁定(死等)
func (this *RWLocker) WaitLock() {
    this.Lock(-1)
}

// 解写锁
func (this *RWLocker) Unlock() {
    atomic.CompareAndSwapInt32(this.write, 1, 0)
}

// 读锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *RWLocker) RLock(timeout int) (success bool) {
    interval := 3 * time.Millisecond
    leftTimeout := timeout

    for {
        if timeout > 0 {
            // 由于是先扣除时间，所以判断timeout时使用timeout<0，而不是timeout<=0
            leftTimeout--
            if leftTimeout < 0 {
                return
            }
        }

        // 如果已经有写锁，则等待
        if *this.write == 1 {
            time.Sleep(interval)
            continue
        }

        // 如果没有写锁，则将读+1
        atomic.AddInt32(this.read, 1)

        // 再次判断是否有写锁，如果有，则将读-1；并重新进行循环判断
        if *this.write == 1 {
            atomic.AddInt32(this.read, -1)
            time.Sleep(interval)
            continue
        }

        success = true
        return
    }

    return
}

// 读锁定(死等)
func (this *RWLocker) WaitRLock() {
    this.RLock(-1)
}

// 解读锁
func (this *RWLocker) RUnlock() {
    atomic.AddInt32(this.read, -1)
}

// 创建新的读写锁对象
func NewRWLocker() *RWLocker {
    read, write := int32(0), int32(0)
    return &RWLocker{
        read:  &read,
        write: &write,
    }
}

版本二：

版本一的读写锁由于要维护两个变量read和write，导致代码的可读性和可维护性很差；那么有没有可能不使用atomic提供的原子方法呢？
直接引入sync.Mutex如何呢？可是我明明就是因为sync.Mutex和sync.RWMutex不提供超时机制，我们才需要来自己实现的，为什么又把它引入进来了呢？
sync.Mutex和sync.RWMutex本身不提供超时机制，但是我们可以对它进行扩展，使得我们定义的对象具有超时的功能。而借助sync.Mutex可以使得代码变得非常简洁。
同时为了在发生死锁的时候，能够获得上次成功获得锁的调用信息，支持记录上次成功调用的堆栈信息。

locker.go

package syncUtil

import (
    "runtime/debug"
    "sync"
    "time"

    "public.com/goutil/logUtil"
)

// 写锁对象
type Locker struct {
    write int
    mutex sync.Mutex

    // Debug related information
    isDebug   bool
    debugInfo string
}

// 内部锁
// 返回值：
// 加锁是否成功
func (this *Locker) lock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 {
        return false
    }

    // 否则，将对象锁定，并返回成功
    this.write = 1

    // 写入Debug信息
    if this.isDebug {
        this.debugInfo = string(debug.Stack())
    }

    return true
}

// 尝试加锁，如果在指定的时间内失败，则会返回失败；否则返回成功
// timeout:指定的毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *Locker) Lock(timeout int) bool {
    leftTimeout := timeout

    for {
        // 如果锁定成功，则返回成功
        if this.lock() {
            return true
        }

        // 否则，则将等待时间递减
        // 如果timeout > 0，表明是超时机制
        if timeout > 0 {
            leftTimeout--
            if leftTimeout == 0 {
                if this.isDebug {
                    logUtil.ErrorLog("Lock timeout. Last lock debug info is: %s", this.debugInfo)
                }
                break
            }
        }

        time.Sleep(time.Millisecond)
    }

    return false
}

// 锁定（死等方式）
func (this *Locker) WaitLock() {
    this.Lock(0)
}

// 解锁
func (this *Locker) Unlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    this.write = 0

    // 清除debug信息
    this.debugInfo = ""
}

// 创建新的锁对象
func NewLocker() *Locker {
    return &Locker{}
}

// 创建新的锁对象
func NewLockerWithDebug(isDebug bool) *Locker {
    return &Locker{
        isDebug: isDebug,
    }
}

rwLocker.go

package syncUtil

import (
    "runtime/debug"
    "sync"
    "time"

    "public.com/goutil/logUtil"
)

// 读写锁对象
type RWLocker struct {
    read  int
    write int
    mutex sync.Mutex

    // Debug related information
    isDebug   bool
    debugInfo string
}

// 尝试加写锁
// 返回值：加写锁是否成功
func (this *RWLocker) lock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 || this.read > 0 {
        return false
    }

    // 否则，将对象锁定，并返回成功
    this.write = 1

    // 写入Debug信息
    if this.isDebug {
        this.debugInfo = string(debug.Stack())
    }

    return true
}

// 写锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *RWLocker) Lock(timeout int) (success bool) {
    leftTimeout := timeout

    for {
        // 如果锁定成功，则返回成功
        if this.lock() {
            return true
        }

        // 否则，则将等待时间递减
        // 如果timeout > 0，表明是超时机制
        if timeout > 0 {
            leftTimeout--
            if leftTimeout == 0 {
                if this.isDebug {
                    logUtil.ErrorLog("Lock timeout. Last lock debug info is: %s", this.debugInfo)
                }
                break
            }
        }

        time.Sleep(time.Millisecond)
    }

    return false
}

// 写锁定(死等)
func (this *RWLocker) WaitLock() {
    this.Lock(0)
}

// 释放写锁
func (this *RWLocker) Unlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    this.write = 0

    // 清除debug信息
    this.debugInfo = ""
}

// 尝试加读锁
// 返回值：加读锁是否成功
func (this *RWLocker) rlock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 {
        return false
    }

    // 否则，将对象锁定，并返回成功
    this.read += 1

    // 写入Debug信息
    if this.isDebug {
        this.debugInfo = string(debug.Stack())
    }

    return true
}

// 读锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
func (this *RWLocker) RLock(timeout int) (success bool) {
    leftTimeout := timeout

    for {
        // 如果锁定成功，则返回成功
        if this.rlock() {
            return true
        }

        // 否则，则将等待时间递减
        // 如果timeout > 0，表明是超时机制
        if timeout > 0 {
            leftTimeout--
            if leftTimeout == 0 {
                if this.isDebug {
                    logUtil.ErrorLog("Lock timeout. Last lock debug info is: %s", this.debugInfo)
                }
                break
            }
        }

        // 读锁比写锁的优先级更低，所以需要等待更长的时间
        time.Sleep(2 * time.Millisecond)
    }

    return false
}

// 读锁定(死等)
func (this *RWLocker) WaitRLock() {
    this.RLock(0)
}

// 释放读锁
func (this *RWLocker) RUnlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    if this.read > 0 {
        this.read -= 1
    }

    // 清除debug信息
    this.debugInfo = ""
}

// 创建新的读写锁对象
func NewRWLocker() *RWLocker {
    return &RWLocker{}
}

func NewRWLockerWithDebug(isDebug bool) *RWLocker {
    return &RWLocker{
        isDebug: isDebug,
    }
}

版本三：

版本二的代码已经很简洁了，也很好维护；但是在超时判断的时候，对于超时和非超时的处理，模型不一致，导致会增加维护的复杂度。
同时也将记录上次成功加锁时的堆栈信息记录设计为了固定逻辑，而非可选逻辑。

syncUtil.go

/*
由于Go不提供超时锁，所以自己实现了支持超时机制的互斥锁Locker和读写锁RWLocker。
为了方便供第三方程序使用，提供了根据Key获取超时互斥锁和超时读写锁的复合对象LockerUtil和RWLockerUtil。
为了在出现锁超时时方便查找问题，会记录上次成功获得锁时的堆栈信息；并且在本次获取锁失败时，同时返回上次成功时的堆栈信息和本次的堆栈信息。
*/
package syncUtil

const (
    // 默认超时的毫秒数(1小时)
    con_Default_Timeout_Milliseconds = 60 * 60 * 1000

    // 写锁每次休眠的时间比读锁的更短，这样是因为写锁有更高的优先级，所以尝试的频率更大
    // 写锁每次休眠的毫秒数
    con_Lock_Sleep_Millisecond = 1

    // 读锁每次休眠的毫秒数
    con_RLock_Sleep_Millisecond = 2
)

// 获取超时时间
func getTimeout(timeout int) int {
    if timeout > 0 {
        return timeout
    } else {
        return con_Default_Timeout_Milliseconds
    }
}

locker.go

package syncUtil

import (
    "fmt"
    "runtime/debug"
    "sync"
    "time"
)

// 写锁对象
type Locker struct {
    write     int // 使用int而不是bool值的原因，是为了与RWLocker中的read保持类型的一致；
    prevStack []byte
    mutex     sync.Mutex
}

// 内部锁
// 返回值：
// 加锁是否成功
func (this *Locker) lock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 {
        return false
    }

    // 否则，将写锁数量设置为１，并返回成功
    this.write = 1

    // 记录Stack信息
    this.prevStack = debug.Stack()

    return true
}

// 尝试加锁，如果在指定的时间内失败，则会返回失败；否则返回成功
// timeout:指定的毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
// 如果失败，返回上一次成功加锁时的堆栈信息
// 如果失败，返回当前的堆栈信息
func (this *Locker) Lock(timeout int) (successful bool, prevStack string, currStack string) {
    timeout = getTimeout(timeout)

    // 遍历指定的次数（即指定的超时时间）
    for i := 0; i < timeout; i = i + con_Lock_Sleep_Millisecond {
        // 如果锁定成功，则返回成功
        if this.lock() {
            successful = true
            break
        }

        // 如果锁定失败，则休眠con_Lock_Sleep_Millisecond ms，然后再重试
        time.Sleep(con_Lock_Sleep_Millisecond * time.Millisecond)
    }

    // 如果时间结束仍然是失败，则返回上次成功的堆栈信息，以及当前的堆栈信息
    if successful == false {
        prevStack = string(this.prevStack)
        currStack = string(debug.Stack())
    }

    return
}

// 锁定（死等方式）
func (this *Locker) WaitLock() {
    successful, prevStack, currStack := this.Lock(0)
    if successful == false {
        fmt.Printf("Locker.WaitLock():{PrevStack:%s, currStack:%s}\n", prevStack, currStack)
    }
}

// 解锁
func (this *Locker) Unlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    this.write = 0
}

// 创建新的锁对象
func NewLocker() *Locker {
    return &Locker{}
}

rwLocker.go

package syncUtil

import (
    "fmt"
    "runtime/debug"
    "sync"
    "time"
)

// 读写锁对象
type RWLocker struct {
    read      int
    write     int // 使用int而不是bool值的原因，是为了与read保持类型的一致；
    prevStack []byte
    mutex     sync.Mutex
}

// 尝试加写锁
// 返回值：加写锁是否成功
func (this *RWLocker) lock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 || this.read > 0 {
        return false
    }

    // 否则，将写锁数量设置为１，并返回成功
    this.write = 1

    // 记录Stack信息
    this.prevStack = debug.Stack()

    return true
}

// 写锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
// 如果失败，返回上一次成功加锁时的堆栈信息
// 如果失败，返回当前的堆栈信息
func (this *RWLocker) Lock(timeout int) (successful bool, prevStack string, currStack string) {
    timeout = getTimeout(timeout)

    // 遍历指定的次数（即指定的超时时间）
    for i := 0; i < timeout; i = i + con_Lock_Sleep_Millisecond {
        // 如果锁定成功，则返回成功
        if this.lock() {
            successful = true
            break
        }

        // 如果锁定失败，则休眠con_Lock_Sleep_Millisecond ms，然后再重试
        time.Sleep(con_Lock_Sleep_Millisecond * time.Millisecond)
    }

    // 如果时间结束仍然是失败，则返回上次成功的堆栈信息，以及当前的堆栈信息
    if successful == false {
        prevStack = string(this.prevStack)
        currStack = string(debug.Stack())
    }

    return
}

// 写锁定(死等)
func (this *RWLocker) WaitLock() {
    successful, prevStack, currStack := this.Lock(0)
    if successful == false {
        fmt.Printf("RWLocker:WaitLock():{PrevStack:%s, currStack:%s}\n", prevStack, currStack)
    }
}

// 释放写锁
func (this *RWLocker) Unlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    this.write = 0
}

// 尝试加读锁
// 返回值：加读锁是否成功
func (this *RWLocker) rlock() bool {
    this.mutex.Lock()
    defer this.mutex.Unlock()

    // 如果已经被锁定，则返回失败
    if this.write == 1 {
        return false
    }

    // 否则，将读锁数量加１，并返回成功
    this.read += 1

    // 记录Stack信息
    this.prevStack = debug.Stack()

    return true
}

// 读锁定
// timeout:超时毫秒数,timeout<=0则将会死等
// 返回值：
// 成功或失败
// 如果失败，返回上一次成功加锁时的堆栈信息
// 如果失败，返回当前的堆栈信息
func (this *RWLocker) RLock(timeout int) (successful bool, prevStack string, currStack string) {
    timeout = getTimeout(timeout)

    // 遍历指定的次数（即指定的超时时间）
    // 读锁比写锁优先级更低，所以每次休眠2ms，所以尝试的次数就是时间/2
    for i := 0; i < timeout; i = i + con_RLock_Sleep_Millisecond {
        // 如果锁定成功，则返回成功
        if this.rlock() {
            successful = true
            break
        }

        // 如果锁定失败，则休眠2ms，然后再重试
        time.Sleep(con_RLock_Sleep_Millisecond * time.Millisecond)
    }

    // 如果时间结束仍然是失败，则返回上次成功的堆栈信息，以及当前的堆栈信息
    if successful == false {
        prevStack = string(this.prevStack)
        currStack = string(debug.Stack())
    }

    return
}

// 读锁定(死等)
func (this *RWLocker) WaitRLock() {
    successful, prevStack, currStack := this.RLock(0)
    if successful == false {
        fmt.Printf("RWLocker:WaitRLock():{PrevStack:%s, currStack:%s}\n", prevStack, currStack)
    }
}

// 释放读锁
func (this *RWLocker) RUnlock() {
    this.mutex.Lock()
    defer this.mutex.Unlock()
    if this.read > 0 {
        this.read -= 1
    }
}

// 创建新的读写锁对象
func NewRWLocker() *RWLocker {
    return &RWLocker{}
}

完整的代码，请参考：https://github.com/Jordanzuo/goutil/tree/master/syncUtil

Go超时锁的设计和实现

Go提供两种锁：sync.Mutex和sync.RWMutex。

版本一：

版本二：

版本三：

猜你喜欢

热点阅读