为什么推荐使用 redis 分布式锁

import (
    "github.com/go-redis/redis/v8"
    "context"
    "time"
)

func acquireLock(rdb *redis.Client, lockKey string, value string, expiration time.Duration) bool {
    // 单条原子命令实现加锁
    result, err := rdb.SetNX(context.Background(), lockKey, value, expiration).Result()
    if err != nil {
        return false
    }
    return result
}

package main

import (
    "context"
    "errors"
    "fmt"
    "time"

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

// RedisLock Redis 分布式锁结构体
type RedisLock struct {
    client     *redis.Client
    lockKey    string        // 锁的 key
    lockValue  string        // 锁的 value（用于解锁时的身份验证）
    expireTime time.Duration // 锁的过期时间
    retryTimes int           // 加锁失败后的重试次数
    retryDelay time.Duration // 重试间隔
}

// NewRedisLock 创建 Redis 分布式锁实例
func NewRedisLock(client *redis.Client, lockKey string) *RedisLock {
    return &RedisLock{
        client:     client,
        lockKey:    lockKey,
        lockValue:  fmt.Sprintf("lock_val_%d", time.Now().UnixNano()), // 用时间戳生成唯一 value
        expireTime: 3 * time.Second,                                  // 锁默认过期时间 3 秒
        retryTimes: 3,                                                // 默认重试 3 次
        retryDelay: 500 * time.Millisecond,                           // 重试间隔 500 毫秒
    }
}

// Lock 加锁（支持重试）
func (rl *RedisLock) Lock(ctx context.Context) (bool, error) {
    // 循环重试加锁
    for i := 0; i tryTimes; i++ {
        // SET key value NX EX：原子操作，确保加锁原子性
        // NX：只有 key 不存在时才设置成功（加锁成功）
        // EX：设置 key 的过期时间，避免死锁
        success, err := rl.client.SetNX(
            ctx,
            rl.lockKey,
            rl.lockValue,
            rl.expireTime,
        ).Result()
        if err != nil {
            fmt.Printf("加锁失败，错误信息：%v\n", err)
            return false, err
        }
        if success {
            fmt.Println("加锁成功")
            return true, nil
        }
        fmt.Printf("加锁失败，第 %d 次重试...\n", i+1)
        time.Sleep(rl.retryDelay)
    }
    return false, errors.New("加锁失败，已达到最大重试次数")
}

// Unlock 解锁（通过 Lua 脚本确保原子性）
func (rl *RedisLock) Unlock(ctx context.Context) error {
    // Lua 脚本：先判断锁的 value 是否匹配（避免误解锁他人的锁），再删除 key
    luaScript := `
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        end
        return 0
    `
    result, err := rl.client.Eval(
        ctx,
        luaScript,
        []string{rl.lockKey},
        rl.lockValue,
    ).Result()
    if err != nil {
        return fmt.Errorf("解锁失败：%v", err)
    }
    if res, ok := result.(int64); ok && res == 1 {
        fmt.Println("解锁成功")
        return nil
    }
    return errors.New("解锁失败：锁不存在或已过期")
}

func main() {
    // 初始化 Redis 客户端
    redisClient := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // 无密码
        DB:       0,  // 使用 0 号数据库
    })
    defer redisClient.Close()

    ctx := context.Background()
    // 创建分布式锁实例（锁 key 为 "stock_lock"，用于保护库存操作）
    lock := NewRedisLock(redisClient, "stock_lock")
    // 自定义锁过期时间（可选）
    lock.expireTime = 5 * time.Second

    // 加锁
    success, err := lock.Lock(ctx)
    if err != nil || !success {
        fmt.Printf("加锁失败：%v\n", err)
        return
    }
    defer lock.Unlock(ctx) // 延迟解锁，确保临界操作执行完后释放锁

    // 临界操作：模拟扣减库存
    fmt.Println("执行临界操作：扣减库存...")
    time.Sleep(2 * time.Second) // 模拟业务执行时间
    fmt.Println("临界操作执行完成")
}