// 简化版伪代码：惰性 + 定期
class RedisExpire {
    static Map<String, Object> redis = new HashMap<>();
    static Map<String, Long> expire = new HashMap<>();

    static {
        // 守护线程：每 10 秒扫描一次过期 key
        threadPool.submit(() -> {
            while (true) {
                Thread.sleep(10000);
                expire.forEach((k, v) -> {
                    if (System.currentTimeMillis() > v) {
                        redis.remove(k);
                    }
                });
            }
        });
    }

    public static Object get(String key) {
        // 惰性删除：取数据时检查
        if (expire.containsKey(key) && System.currentTimeMillis() > expire.get(key)) {
            redis.remove(key);
            expire.remove(key);
        }
        return redis.get(key);
    }
}

// 守护线程每隔过期时间的 1/3 检查并续命
ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
    String script = "if redis.call('GET', KEYS[1]) == ARGV[1] " +
                    "then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end";
    jedis.eval(script, ..., Arrays.asList(clientId, String.valueOf(expireTime)));
}, 0, expireTime / 3, TimeUnit.MILLISECONDS);

String script = "if redis.call('GET', KEYS[1]) == ARGV[1] " +
                "then return redis.call('DEL', KEYS[1]) else return 0 end";
jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(clientId));

public class RedisLock {

    /** 获取锁 */
    public static boolean tryLock(Jedis jedis, String lockKey, String clientId, long expireTime) {
        String result = jedis.set(lockKey, clientId, "NX", "PX", expireTime);
        return "OK".equals(result);
    }

    /** 启动锁续命线程 */
    public static ScheduledFuture<?> startRenewThread(Jedis jedis, String lockKey,
                                                      String clientId, long expireTime) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        return executor.scheduleAtFixedRate(() -> {
            String script = "if redis.call('GET', KEYS[1]) == ARGV[1] " +
                            "then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end";
            Long result = jedis.eval(script, Collections.singletonList(lockKey),
                                     Arrays.asList(clientId, String.valueOf(expireTime)));
            if (result != 1) executor.shutdown();
        }, 0, expireTime / 3, TimeUnit.MILLISECONDS);
    }

    /** 释放锁（Lua 脚本保证原子性） */
    public static boolean releaseLock(Jedis jedis, String lockKey, String clientId,
                                      ScheduledFuture<?> renewFuture) {
        if (renewFuture != null) renewFuture.cancel(true);
        String script = "if redis.call('GET', KEYS[1]) == ARGV[1] " +
                        "then return redis.call('DEL', KEYS[1]) else return 0 end";
        Long result = (Long) jedis.eval(script,
                Collections.singletonList(lockKey),
                Collections.singletonList(clientId));
        return result == 1;
    }

    // 使用示例
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        String lockKey = "lock:stock";
        String clientId = UUID.randomUUID().toString();
        long expireTime = 30000;

        ScheduledFuture<?> renewFuture = null;
        try {
            if (!tryLock(jedis, lockKey, clientId, expireTime)) {
                System.out.println("获取锁失败");
                return;
            }
            renewFuture = startRenewThread(jedis, lockKey, clientId, expireTime);

            // 执行业务（如扣减库存）
            executeBusinessLogic();

        } finally {
            releaseLock(jedis, lockKey, clientId, renewFuture);
            jedis.close();
        }
    }
}

// 1. 引入依赖
// <dependency>
//     <groupId>org.redisson</groupId>
//     <artifactId>redisson</artifactId>
// </dependency>

// 2. 初始化客户端
Config config = new Config();
config.useSingleServer().setAddress("redis://localhost:6379");
RedissonClient redisson = Redisson.create(config);

// 3. 获取并使用分布式锁
RLock lock = redisson.getLock("lock:stock");
try {
    // 最多等待 10 秒；获取后 30 秒自动过期
    boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (locked) {
        // 执行业务（看门狗自动续命）
        executeTask();
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 只有持有锁时才释放
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}
redisson.shutdown();