// 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 }