目录
- 为什么需要分布式锁
- 分布式锁需要具备特性
- 实现 redis 锁应先掌握哪些知识点
- set 命令
- redis.lua 脚本
- go-zero 分布式锁 redislock 源码分析
- 关于分布式锁还有哪些实现方案
- 项目地址
为什么需要分布式锁
用户下单
锁住 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分布式锁内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！