Go 接入 Redis 分布式锁实战：SETNX、Lua 脚本与看门狗续期完整教程

var mu sync.Mutex

func DeductStock() {
    mu.Lock()
    defer mu.Unlock()
    // 扣库存...
}

// go-redis/v9 中 SetNX 直接支持过期时间参数，底层就是 SET NX PX
ok, err := rdb.SetNX(ctx, "order:deduct:sku_1001", token, 10*time.Second).Result()
if err != nil {
    return err
}
if ok {
    // 拿到锁了
}

if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

for {
    ok, err := rdb.SetNX(ctx, key, token, expiration).Result()
    if err != nil {
        return false, err
    }
    if ok {
        return true, nil
    }
    select {
    case <-ctx.Done(): // 总超时，放弃
        return false, nil
    case <-time.After(200 * time.Millisecond): // 隔 200ms 再抢
    }
}

renewScript := redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("pexpire", KEYS[1], ARGV[2])
else
    return 0
end`)

func (l *RedisLock) startWatchdog(ctx context.Context) {
    interval := l.expiration / 3
    go func() {
        ticker := time.NewTicker(interval)
        defer ticker.Stop()
        for {
            select {
            case <-ctx.Done():
                return
            case <-ticker.C:
                res, err := renewScript.Run(ctx, l.rdb,
                    []string{l.key}, l.token, l.expiration.Milliseconds()).Result()
                if err != nil || res == int64(0) {
                    return // 锁已不属于自己，停止续期
                }
            }
        }
    }()
}

package main

import (
    "context"
    "crypto/rand"
    "encoding/hex"
    "errors"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
)

var (
    ErrNotHeld = errors.New("redis: lock not held by this token")

    unlockScript = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end`)

    renewScript = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("pexpire", KEYS[1], ARGV[2])
else
    return 0
end`)
)

type RedisLock struct {
    rdb        *redis.Client
    key        string
    token      string
    expiration time.Duration
    cancel     context.CancelFunc
}

func NewRedisLock(rdb *redis.Client, key string, expiration time.Duration) *RedisLock {
    b := make([]byte, 16)
    _, _ = rand.Read(b)
    return &RedisLock{
        rdb: rdb, key: key, token: hex.EncodeToString(b), expiration: expiration,
    }
}

// Lock 自旋重试加锁；ctx 超时仍未拿到锁则返回 false
func (l *RedisLock) Lock(ctx context.Context) (bool, error) {
    for {
        ok, err := l.rdb.SetNX(ctx, l.key, l.token, l.expiration).Result()
        if err != nil {
            return false, err
        }
        if ok {
            watchdogCtx, cancel := context.WithCancel(context.Background())
            l.cancel = cancel
            l.startWatchdog(watchdogCtx)
            return true, nil
        }
        select {
        case <-ctx.Done():
            return false, nil
        case <-time.After(200 * time.Millisecond):
        }
    }
}

func (l *RedisLock) startWatchdog(ctx context.Context) {
    interval := l.expiration / 3
    go func() {
        ticker := time.NewTicker(interval)
        defer ticker.Stop()
        for {
            select {
            case <-ctx.Done():
                return
            case <-ticker.C:
                res, err := renewScript.Run(ctx, l.rdb,
                    []string{l.key}, l.token, l.expiration.Milliseconds()).Result()
                if err != nil || res == int64(0) {
                    return
                }
            }
        }
    }()
}

// Unlock Lua 脚本原子释放，并停止看门狗
func (l *RedisLock) Unlock(ctx context.Context) error {
    if l.cancel != nil {
        l.cancel()
    }
    res, err := unlockScript.Run(ctx, l.rdb, []string{l.key}, l.token).Result()
    if err != nil {
        return err
    }
    if n, ok := res.(int64); !ok || n != 1 {
        return ErrNotHeld
    }
    return nil
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    defer rdb.Close()

    ctx := context.Background()
    lock := NewRedisLock(rdb, "order:deduct:sku_1001", 10*time.Second)

    ok, err := lock.Lock(ctx)
    if err != nil {
        panic(err)
    }
    if !ok {
        fmt.Println("未抢到锁，请稍后重试")
        return
    }
    defer lock.Unlock(context.Background()) // 业务 panic 也能释放

    fmt.Println("抢到锁，开始处理业务...")
    time.Sleep(3 * time.Second)
    fmt.Println("业务完成，锁已释放")
}