Go超时锁的设计和实现

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

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,491评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,856评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,745评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,196评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,073评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,112评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,531评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,215评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,485评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,578评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,356评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,215评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,583评论 3赞 299
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,898评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,174评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,497评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,697评论 2赞 335