#Redis 分布式锁

// 错误实现
public String acquireLock(String key) {
    return redisTemplate.opsForValue().setIfAbsent(key, "lock", 10, TimeUnit.SECONDS);
}

// 释放锁时
public void releaseLock(String key) {
    redisTemplate.delete(key);
}

// 正确实现
@Service
public class RedisDistributedLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    // 获取锁
    public String acquireLock(String lockKey, long expireTime, TimeUnit unit) {
        // 生成唯一值（用于释放锁时校验）
        String uuid = UUID.randomUUID().toString();
        long timeout = unit.toSeconds(expireTime);

        // SET key value NX EX timeout
        // NX: 只有 key 不存在时才设置
        // EX: 设置过期时间
        Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, uuid, expireTime, unit);

        if (Boolean.TRUE.equals(result)) {
            return uuid; // 获取锁成功，返回唯一值
        }
        return null; // 获取锁失败
    }

    // 释放锁
    public boolean releaseLock(String lockKey, String uuid) {
        // 错误的释放方式：
        // redisTemplate.delete(lockKey); // ❌ 直接删除会删掉别人的锁

        // 正确的释放方式：用 Lua 脚本保证原子性
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "return redis.call('del', KEYS[1]) " +
                        "else return 0 end";

        RedisScript<Long> redisScript = RedisScript.of(script, Long.class);
        Long result = redisTemplate.execute(redisScript,
            Collections.singletonList(lockKey), uuid);

        return result != null && result == 1L;
    }

    // 续期（看门狗）
    public boolean renewLock(String lockKey, String uuid, long expireTime, TimeUnit unit) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "return redis.call('expire', KEYS[1], ARGV[2]) " +
                        "else return 0 end";

        RedisScript<Long> redisScript = RedisScript.of(script, Long.class);
        Long result = redisTemplate.execute(redisScript,
            Collections.singletonList(lockKey), uuid, unit.toSeconds(expireTime));

        return result != null && result == 1L;
    }
}

// Redisson 的看门狗实现
@Service
public class RedissonDistributedLock {

    @Autowired
    private RedissonClient redissonClient;

    public void executeWithLock(String lockKey, Runnable task) {
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 尝试获取锁，等待 10 秒，锁定 30 秒
            // 看门狗机制：每 10 秒自动续期
            boolean acquired = lock.tryLock(10, 30, TimeUnit.SECONDS);

            if (acquired) {
                task.run();
            } else {
                throw new RuntimeException("获取锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断");
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

// RedLock：多个 Redis 节点实现分布式锁
@Service
public class RedissonRedLock {

    private RedissonClient[] redissonClients;

    public boolean tryLockWithRedLock(String lockKey, long waitTime, long leaseTime) {
        // 获取多个 RedissonClient 实例
        RedissonClient[] clients = getRedissonClients();
        int N = clients.length;
        int successCount = 0;
        long startTime = System.currentTimeMillis();

        // 向 N 个实例获取锁
        for (int i = 0; i < N; i++) {
            try {
                RLock lock = clients[i].getLock(lockKey);
                boolean acquired = lock.tryLock(waitTime, leaseTime, TimeUnit.MILLISECONDS);
                if (acquired) {
                    successCount++;
                }
            } catch (Exception e) {
                // 单个实例失败，继续尝试其他实例
            }
        }

        // 计算是否获取了多数派的锁
        return successCount > N / 2;
    }

    public void unlockWithRedLock(String lockKey) {
        // 向所有实例释放锁
        for (RedissonClient client : getRedissonClients()) {
            try {
                RLock lock = client.getLock(lockKey);
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            } catch (Exception e) {
                // 单个实例失败，继续释放其他
            }
        }
    }
}

// ❌ 错误：锁过期时间设置不合理
public void badLock(String lockKey) {
    String uuid = acquireLock(lockKey, 10, TimeUnit.SECONDS);
    if (uuid == null) return;

    // 业务执行需要 15 秒
    doBusiness(); // 15 秒后锁已自动释放
    // 其他线程获取了锁，导致重复执行

    releaseLock(lockKey, uuid);
}

// ✅ 正确：使用看门狗或预估合理的过期时间
public void goodLock(String lockKey) {
    // Redisson 自动续期
    RLock lock = redissonClient.getLock(lockKey);
    lock.tryLock(); // 自动续期，不用担心过期

    try {
        doBusiness(); // 任意时长
    } finally {
        lock.unlock();
    }
}