乘风原创程序

  • 用Go+Redis实现分布式锁的示例代码
  • 2021/12/17 12:09:43
  • 为什么需要分布式锁

    用户下单
    锁住 uid,防止重复下单。

    库存扣减
    锁住库存,防止超卖。

    余额扣减
    锁住账户,防止并发操作。
    分布式系统中共享同一个资源时往往需要分布式锁来保证变更资源一致性。

    分布式锁需要具备特性

    排他性
    锁的基本特性,并且只能被第一个持有者持有。

    防死锁
    高并发场景下临界资源一旦发生死锁非常难以排查,通常可以通过设置超时时间到期自动释放锁来规避。

    可重入
    锁持有者支持可重入,防止锁持有者再次重入时锁被超时释放。

    高性能高可用
    锁是代码运行的关键前置节点,一旦不可用则业务直接就报故障了。高并发场景下,高性能高可用是基本要求。

    实现 redis 锁应先掌握哪些知识点

    set 命令

    set key value [ex seconds] [px milliseconds] [nx|xx]
    
    • ex second :设置键的过期时间为 second 秒。 set key value ex second 效果等同于 setex key second value 。
    • px millisecond :设置键的过期时间为 millisecond 毫秒。 set key value px millisecond 效果等同于 psetex key millisecond value 。
    • nx :只在键不存在时,才对键进行设置操作。 set key value nx 效果等同于 setnx key value 。
    • xx :只在键已经存在时,才对键进行设置操作。

    redis.lua 脚本

    使用 redis lua 脚本能将一系列命令操作封装成 pipline 实现整体操作的原子性。

    go-zero 分布式锁 redislock 源码分析

    core/stores/redis/redislock.go

    加锁流程

    -- keys[1]: 锁key
    -- argv[1]: 锁value,随机字符串
    -- argv[2]: 过期时间
    -- 判断锁key持有的value是否等于传入的value
    -- 如果相等说明是再次获取锁并更新获取时间,防止重入时过期
    -- 这里说明是“可重入锁”
    if redis.call("get", keys[1]) == argv[1] then
        -- 设置
        redis.call("set", keys[1], argv[1], "px", argv[2])
        return "ok"
    
    else
        -- 锁key.value不等于传入的value则说明是第一次获取锁
        -- set key value nx px timeout : 当key不存在时才设置key的值
        -- 设置成功会自动返回“ok”,设置失败返回“null bulk reply”
        -- 为什么这里要加“nx”呢,因为需要防止把别人的锁给覆盖了
        return redis.call("set", keys[1], argv[1], "nx", "px", argv[2])
    end
    
    

    解锁流程

    -- 释放锁
    -- 不可以释放别人的锁
    if redis.call("get", keys[1]) == argv[1] then
        -- 执行成功返回“1”
        return redis.call("del", keys[1])
    else
        return 0
    end
    

    源码解析

    package redis
    
    import (
        "math/rand"
        "strconv"
        "sync/atomic"
        "time"
    
        red "github.com/go-redis/redis"
        "github.com/tal-tech/go-zero/core/logx"
    )
    
    const (
        letters     = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
        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`
        delcommand = `if redis.call("get", keys[1]) == argv[1] then
        return redis.call("del", keys[1])
    else
        return 0
    end`
        randomlen = 16
        // 默认超时时间,防止死锁
        tolerance       = 500 // milliseconds
        millispersecond = 1000
    )
    
    // a redislock is a redis lock.
    type redislock struct {
        // redis客户端
        store *redis
        // 超时时间
        seconds uint32
        // 锁key
        key string
        // 锁value,防止锁被别人获取到
        id string
    }
    
    func init() {
        rand.seed(time.now().unixnano())
    }
    
    // newredislock returns a redislock.
    func newredislock(store *redis, key string) *redislock {
        return &redislock{
            store: store,
            key:   key,
            // 获取锁时,锁的值通过随机字符串生成
            // 实际上go-zero提供更加高效的随机字符串生成方式
            // 见core/stringx/random.go:randn
            id:    randomstr(randomlen),
        }
    }
    
    // acquire acquires the lock.
    // 加锁
    func (rl *redislock) acquire() (bool, error) {
        // 获取过期时间
        seconds := atomic.loaduint32(&rl.seconds)
        // 默认锁过期时间为500ms,防止死锁
        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
        }
    
        logx.errorf("unknown reply when acquiring lock for %s: %v", rl.key, resp)
        return false, nil
    }
    
    // release releases the lock.
    // 释放锁
    func (rl *redislock) release() (bool, error) {
        resp, err := rl.store.eval(delcommand, []string{rl.key}, []string{rl.id})
        if err != nil {
            return false, err
        }
    
        reply, ok := resp.(int64)
        if !ok {
            return false, nil
        }
    
        return reply == 1, nil
    }
    
    // setexpire sets the expire.
    // 需要注意的是需要在acquire()之前调用
    // 不然默认为500ms自动释放
    func (rl *redislock) setexpire(seconds int) {
        atomic.storeuint32(&rl.seconds, uint32(seconds))
    }
    
    func randomstr(n int) string {
        b := make([]byte, n)
        for i := range b {
            b[i] = letters[rand.intn(len(letters))]
        }
        return string(b)
    }
    
    

    关于分布式锁还有哪些实现方案

    etcd
    redis redlock

    项目地址

    https://github.com/zeromicro/go-zero

    到此这篇关于用go+redis实现分布式锁的示例代码的文章就介绍到这了,更多相关go redis分布式锁内容请搜索本教程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持本教程网!