分布式缓存与分布式锁高可用架构完全指南 2026：Redis vs Dragonfly vs KeyDB + 缓存防线 + Redlock 实战

1
package main
2

3
import (
4
  "context"
5
  "errors"
6
  "fmt"
7
  "sync"
8
  "time"
9

10
  "github.com/google/uuid"
11
  "github.com/redis/go-redis/v9"
12
)
13

14
type DistributedLock struct {
15
  client     *redis.Client
16
  key        string
17
  token      string
18
  ttl        time.Duration
19
  cancelFunc context.CancelFunc
20
  mutex      sync.Mutex
21
}
22

23
func NewLock(client *redis.Client, key string, ttl time.Duration) *DistributedLock {
24
  return &DistributedLock{
25
    client: client,
26
    key:    key,
27
    token:  uuid.New().String(), // 唯一随机 Token 防误删
28
    ttl:    ttl,
29
  }
30
}
31

32
// Lock 加锁并自动启动 Watchdog 自动续期
33
func (l *DistributedLock) Lock(ctx context.Context) error {
34
  // 1. 原子加锁
35
  ok, err := l.client.SetNX(ctx, l.key, l.token, l.ttl).Result()
36
  if err != nil {
37
    return err
38
  }
39
  if !ok {
40
    return errors.New("failed to acquire lock: resource is busy")
41
  }
42

43
  // 2. 启动后台看门狗 (Watchdog) 自动续期协程
44
  watchCtx, cancel := context.WithCancel(context.Background())
45
  l.cancelFunc = cancel
46
  go l.startWatchdog(watchCtx)
47

48
  return nil
49
}
50

51
func (l *DistributedLock) startWatchdog(ctx context.Context) {
52
  ticker := time.NewTicker(l.ttl / 3) // 每 1/3 TTL 续期一次
53
  defer ticker.Stop()
54

55
  renewScript := redis.NewScript(`
56
    if redis.call("get", KEYS[1]) == ARGV[1] then
57
      return redis.call("pexpire", KEYS[1], ARGV[2])
58
    else
59
      return 0
60
    end
61
  `)
62

63
  for {
64
    select {
65
    case <-ctx.Done():
66
      return
67
    case <-ticker.C:
68
      res, err := renewScript.Run(context.Background(), l.client, []string{l.key}, l.token, l.ttl.Milliseconds()).Result()
69
      if err != nil || res.(int64) == 0 {
70
        return // 锁已被释放或被夺取，停止续期
71
      }
72
    }
73
  }
74
}
75

76
// Unlock 安全释放锁
77
func (l *DistributedLock) Unlock(ctx context.Context) error {
78
  l.mutex.Lock()
79
  defer l.mutex.Unlock()
80

81
  // 停止看门狗
82
  if l.cancelFunc != nil {
83
    l.cancelFunc()
84
  }
85

86
  // 3. Lua 原子校验并删除
87
  releaseScript := redis.NewScript(`
88
    if redis.call("get", KEYS[1]) == ARGV[1] then
89
      return redis.call("del", KEYS[1])
90
    else
91
      return 0
92
    end
93
  `)
94

95
  res, err := releaseScript.Run(ctx, l.client, []string{l.key}, l.token).Result()
96
  if err != nil {
97
    return err
98
  }
99
  if res.(int64) == 0 {
100
    return errors.New("lock already expired or held by another process")
101
  }
102

103
  return nil
104
}
105

106
func main() {
107
  rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
108
  lock := NewLock(rdb, "order:lock:20260913", 10*time.Second)
109

110
  ctx := context.Background()
111
  if err := lock.Lock(ctx); err != nil {
112
    fmt.Printf("Cannot get lock: %v\n", err)
113
    return
114
  }
115
  defer lock.Unlock(ctx)
116

117
  fmt.Println("✅ Acquired distributed lock! Performing critical section...")
118
  time.Sleep(5 * time.Second) // 模拟复杂业务
119
  fmt.Println("🏁 Work finished.")
120
}