既然是锁，首先想到的一个作用就是：防重复点击，在一个时间点只有一个请求产生效果。

而既然是 redis，就得具有排他性，同时也具有锁的一些共性：

  • 高性能
  • 不能出现死锁
  • 不能出现节点down掉后加锁失败

go-zero 中利用 redis set key nx 可以保证key不存在时写入成功，px 可以让key超时后自动删除「最坏情况也就是超时自动删除key，从而也不会出现死锁」

example

redisLockKey := fmt.Sprintf("%v%v", redisTpl, headId)
// 1. New redislock
redisLock := redis.NewRedisLock(redisConn, redisLockKey)
// 2. 可选操作，设置 redislock 过期时间
redisLock.SetExpire(redisLockExpireSeconds)
if ok, err := redisLock.Acquire(); !ok || err != nil {
  return nil, errors.New("当前有其他用户正在进行操作，请稍后重试")
}
defer func() {
  recover()
  // 3. 释放锁
  redisLock.Release()
}()

和你在使用 sync.Mutex 的方式时一致的。加锁解锁，执行你的业务操作。

获取锁

lockCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
    return "OK"
else
    return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
end`

func (rl *RedisLock) Acquire() (bool, error) {
    seconds := atomic.LoadUint32(&rl.seconds)
  // execute luascript
    resp, err := rl.store.Eval(lockCommand, []string{rl.key}, []string{
        rl.id, strconv.Itoa(int(seconds)*millisPerSecond + tolerance)})
    if err == red.Nil {
        return false, nil
    } else if err != nil {
        logx.Errorf("Error on acquiring lock for %s, %s", rl.key, err.Error())
        return false, err
    } else if resp == nil {
        return false, nil
    }

    reply, ok := resp.(string)
    if ok && reply == "OK" {
        return true, nil
    } else {
        logx.Errorf("Unknown reply when acquiring lock for %s: %v", rl.key, resp)
        return false, nil
    }
}

先介绍几个 redis 的命令选项，以下是为 set 命令增加的选项：

  • ex seconds ：设置key过期时间，单位s
  • px milliseconds ：设置key过期时间，单位毫秒
  • nx：key不存在时，设置key的值
  • xx：key存在时，才会去设置key的值

其中 lua script 涉及的入参：

 

args示例含义
KEYS[1]key$20201026redis key
ARGV[1]lmnopqrstuvwxyzABCD唯一标识：随机字符串
ARGV[2]30000设置锁的过期时间

 






然后来说说代码特性：

  1. Lua 脚本保证原子性「当然，把多个操作在 Redis 中实现成一个操作，也就是单命令操作」
  2. 使用了 set key value px milliseconds nx
  3. value 具有唯一性
  4. 加锁时首先判断 key 的 value 是否和之前设置的一致，一致则修改过期时间

释放锁

delCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end`

func (rl *RedisLock) Release() (bool, error) {
    resp, err := rl.store.Eval(delCommand, []string{rl.key}, []string{rl.id})
    if err != nil {
        return false, err
    }

    if reply, ok := resp.(int64); !ok {
        return false, nil
    } else {
        return reply == 1, nil
    }
}

释放锁的时候只需要关注一点：

不能释放别人的锁，不能释放别人的锁，不能释放别人的锁

所以需要先 get(key) == value「key」，为 true 才会去 delete