Files

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
}