179 lines
4.6 KiB
Go
179 lines
4.6 KiB
Go
// Package lock 基于 Redis 的分布式锁(Day 6)。
|
|
// 安全性:value 使用随机令牌,释放与续期均通过 Lua 脚本原子校验,
|
|
// 防止误删他人锁;可用性:后台 watchdog 按间隔自动续期,防止业务未完成锁先过期。
|
|
package lock
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// 错误定义。
|
|
var (
|
|
// ErrLockHeld 锁已被其他持有者占用。
|
|
ErrLockHeld = errors.New("lock: 已被其他持有者持有")
|
|
// ErrLockNotHeld 当前持有者已不再持有该锁(已释放/已过期)。
|
|
ErrLockNotHeld = errors.New("lock: 当前持有者未持有该锁")
|
|
)
|
|
|
|
// 释放脚本:仅当 value 匹配时删除(原子,防误删)。
|
|
const releaseScript = `if redis.call("get", KEYS[1]) == ARGV[1] then
|
|
return redis.call("del", KEYS[1])
|
|
else
|
|
return 0
|
|
end`
|
|
|
|
// 续期脚本:仅当 value 匹配时重置 TTL(原子)。
|
|
const renewScript = `if redis.call("get", KEYS[1]) == ARGV[1] then
|
|
return redis.call("pexpire", KEYS[1], ARGV[2])
|
|
else
|
|
return 0
|
|
end`
|
|
|
|
// 默认参数。
|
|
const (
|
|
defaultRetryInterval = 100 * time.Millisecond // Lock 阻塞获取的轮询间隔
|
|
watchdogFactor = 3 // 续期间隔 = TTL / 3
|
|
)
|
|
|
|
// Locker 分布式锁入口。
|
|
type Locker struct {
|
|
client redis.UniversalClient
|
|
// RetryInterval 阻塞式 Lock 的轮询间隔(默认 100ms,可按需调整)。
|
|
RetryInterval time.Duration
|
|
}
|
|
|
|
// New 创建 Locker;client 可直接使用 cache.Client(其嵌入了 UniversalClient)。
|
|
func New(client redis.UniversalClient) *Locker {
|
|
return &Locker{client: client, RetryInterval: defaultRetryInterval}
|
|
}
|
|
|
|
// Lock 表示一次成功获取的锁;Unlock 后应停止使用。
|
|
type Lock struct {
|
|
client redis.UniversalClient
|
|
key string
|
|
token string
|
|
ttl time.Duration
|
|
stop chan struct{}
|
|
stopOne sync.Once
|
|
}
|
|
|
|
// TryLock 非阻塞获取锁:SET key token NX PX ttl。
|
|
// 被他人占用返回 ErrLockHeld;获取成功即启动 watchdog 自动续期。
|
|
func (l *Locker) TryLock(ctx context.Context, key string, ttl time.Duration) (*Lock, error) {
|
|
if ttl <= 0 {
|
|
return nil, errors.New("lock: ttl 必须大于 0")
|
|
}
|
|
token, err := newToken()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ok, err := l.client.SetNX(ctx, key, token, ttl).Result()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !ok {
|
|
return nil, ErrLockHeld
|
|
}
|
|
lk := &Lock{
|
|
client: l.client,
|
|
key: key,
|
|
token: token,
|
|
ttl: ttl,
|
|
stop: make(chan struct{}),
|
|
}
|
|
lk.startWatchdog()
|
|
return lk, nil
|
|
}
|
|
|
|
// Lock 阻塞获取锁:轮询 TryLock 直到成功或 ctx 取消/超时。
|
|
func (l *Locker) Lock(ctx context.Context, key string, ttl time.Duration) (*Lock, error) {
|
|
interval := l.RetryInterval
|
|
if interval <= 0 {
|
|
interval = defaultRetryInterval
|
|
}
|
|
timer := time.NewTimer(interval)
|
|
defer timer.Stop()
|
|
for {
|
|
lk, err := l.TryLock(ctx, key, ttl)
|
|
if err == nil {
|
|
return lk, nil
|
|
}
|
|
if !errors.Is(err, ErrLockHeld) {
|
|
return nil, err // 连接等底层错误,直接返回
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
case <-timer.C:
|
|
timer.Reset(interval)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Key 返回锁键名。
|
|
func (lk *Lock) Key() string { return lk.key }
|
|
|
|
// TTL 返回锁的初始 TTL。
|
|
func (lk *Lock) TTL() time.Duration { return lk.ttl }
|
|
|
|
// Unlock 释放锁并停止续期;未持有(已释放/被覆盖)返回 ErrLockNotHeld。
|
|
func (lk *Lock) Unlock(ctx context.Context) error {
|
|
lk.stopWatchdog()
|
|
res, err := lk.client.Eval(ctx, releaseScript, []string{lk.key}, lk.token).Int64()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if res != 1 {
|
|
return ErrLockNotHeld
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// startWatchdog 启动自动续期:每 ttl/3 续期一次,Unlock 或续期失败时退出。
|
|
func (lk *Lock) startWatchdog() {
|
|
interval := lk.ttl / watchdogFactor
|
|
if interval < 10*time.Millisecond {
|
|
interval = 10 * time.Millisecond
|
|
}
|
|
go func() {
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-lk.stop:
|
|
return
|
|
case <-ticker.C:
|
|
ctx, cancel := context.WithTimeout(context.Background(), interval)
|
|
res, err := lk.client.Eval(ctx, renewScript,
|
|
[]string{lk.key}, lk.token, lk.ttl.Milliseconds()).Int64()
|
|
cancel()
|
|
if err != nil || res != 1 {
|
|
// 锁已丢失(过期/被删/网络错误):停止续期,业务侧应尽快结束临界区
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
// stopWatchdog 幂等停止续期协程。
|
|
func (lk *Lock) stopWatchdog() {
|
|
lk.stopOne.Do(func() { close(lk.stop) })
|
|
}
|
|
|
|
// newToken 生成 16 字节随机令牌,确保不同持有者 value 不同。
|
|
func newToken() (string, error) {
|
|
b := make([]byte, 16)
|
|
if _, err := rand.Read(b); err != nil {
|
|
return "", err
|
|
}
|
|
return hex.EncodeToString(b), nil
|
|
}
|