用Go语言&&redis,如何写分布式锁 ?
为什么需要分布式锁
1 因为用户下单,需要锁住 uid,防止用户重复下单。
2 用在库存扣减上,锁住库存,可以防止库存超卖。
3 用在余额扣减场景,锁住账户,防止并发操作。
分布式系统中共享同一个资源时,就需要分布式锁来确保变更资源的一致性。这就是为什么要用到分布式锁的原因咯。
分布式锁需要具备特性
1 排他性
这个是锁的基本特性,并且只能被第一个持有者拥有。这个不用解释都明白
2 防死锁
高并发场景下临界资源一旦发生死锁,非常难以排查,通常我们可以通过设置超时,时间到期后就自动释放锁,来规避发生死锁。
3 可重入
锁持有者是支持可重入的,但是防止锁持有者再次重入时,锁被超时释放。
4 高性能,高可用
锁是代码运行的关键前置节点,一旦不可用,则业务直接就报故障。高并发场景下,高性能高可用是基本要求。所以说高并发,高性能,高可用是一并存在的。
实现 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 ,实现整体操作的原子性。
加锁的整个流程,详细原理说明看注释
-- KEYS[1]: 锁key
-- ARGV[1]: 锁value,zh可以是随机字符串
-- 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"
randomLen = 16
// 默认超时时间,用来防止死锁
tolerance = 300 // milliseconds
millisPerSecond = 800
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`
)
type redisLock struct {
// redis客户端
store *Redis
// 超时时间
seconds uint32
// 锁key
keys string
// 锁value,防止锁被别人获取到
value string
}
func init() {
rand.Seed(time.Now().UnixNano())
}
// NewRedisLock returns a RedisLock.
func NewRedisLock(store *Redis, keys string) *RedisLock {
return &RedisLock{
store: store,
keys: keys,
// 获取锁时,锁的值通过随机字符串生成
// 实际上go-zero提供更加高效的随机字符串生成方式
// 见core/stringx/random.go:Randn
value: 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.keys}, []string{
rl.value, strconv.Itoa(int(seconds)*millisPerSecond + tolerance),
})
if err == red.Nil {
return false, nil
} else if err != nil {
logx.Errorf("Error on 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 lock for %s: %v", rl.keys, resp)
return false, nil
}
// Release releases the lock.
// 释放锁
func (rl *RedisLock) Release() (bool, error) {
resp, err := rl.store.Eval(delCommand, []string{rl.keys}, []string{rl.value})
if err != nil {
return false, err
}
reply, ok := resp.(int64)
if !ok {
return false, nil
}
return reply == 1, nil
}
func randomStr(n int) string {
b := make([]byte, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
// SetExpire sets the expire.
// 需要注意的是需要在Acquire()之前调用
// 不然默认为300ms自动释放
func (rl *RedisLock) SetExpire(seconds int) {
atomic.StoreUint32(&rl.seconds, uint32(seconds))
}
这个详细源码根据自己的业务需要,可以利用.
参考链接:https://learnku.com/articles/64413
更多相关Go语言的技术文章或视频教程,请关注本公众号获取并查看,感谢你的支持与信任!