// 锁键
String lockKey = "lock:stock";
// 客户端标识（可以用UUID生成）
String clientId = UUID.randomUUID().toString();
// 执行Lua脚本
String script = "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end";
Long result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(clientId));
if (result == 1) {
    // 释放锁成功
} else {
    // 释放锁失败（锁已过期或被其他客户端持有）
}

/**
 * 获取Redis分布式锁
 * @param jedis Redis客户端
 * @param lockKey 锁键
 * @param clientId 客户端标识（UUID）
 * @param expireTime 过期时间（毫秒）
 * @return 是否获取成功
 */
public static boolean tryLock(Jedis jedis, String lockKey, String clientId, long expireTime) {
    // 用SET NX PX命令获取锁
    String result = jedis.set(lockKey, clientId, "NX", "PX", expireTime);
    // 返回OK表示获取成功
    return "OK".equals(result);
}

/**
 * 启动锁续命线程
 * @param jedis Redis客户端
 * @param lockKey 锁键
 * @param clientId 客户端标识
 * @param expireTime 过期时间（毫秒）
 * @return 用于停止线程的标识
 */
public static ScheduledFuture<?> startRenewThread(Jedis jedis, String lockKey, String clientId, long expireTime) {
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    // 每隔expireTime/3时间执行一次续命（比如30秒过期，每10秒续命一次）
    ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
        // 用Lua脚本判断是否持有锁，是则续命
        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);
    return future;
}

/**
 * 释放Redis分布式锁
 * @param jedis Redis客户端
 * @param lockKey 锁键
 * @param clientId 客户端标识
 * @param renewFuture 续命线程的Future（用于停止线程）
 * @return 是否释放成功
 */
public static boolean releaseLock(Jedis jedis, String lockKey, String clientId, ScheduledFuture<?> renewFuture) {
    // 先停止续命线程
    if (renewFuture != null && !renewFuture.isCancelled()) {
        renewFuture.cancel(true);
    }
    // 用Lua脚本释放锁（判断+删除原子操作）
    String script = "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end";
    Long result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(clientId));
    return result == 1;
}

public class RedisLockExample {
    public static void main(String[] args) {
        // 初始化Redis客户端（实际中建议用连接池）
        Jedis jedis = new Jedis("localhost", 6379);
        String lockKey = "lock:stock";
        String clientId = UUID.randomUUID().toString();
        long expireTime = 30000; // 30秒过期
        
        try {
            // 1. 获取锁
            boolean locked = tryLock(jedis, lockKey, clientId, expireTime);
            if (!locked) {
                System.out.println("获取锁失败，退出");
                return;
            }
            System.out.println("获取锁成功，开始执行任务");
            
            // 2. 启动锁续命线程
            ScheduledFuture<?> renewFuture = startRenewThread(jedis, lockKey, clientId, expireTime);
            
            // 3. 执行核心任务（比如扣减库存）
            executeTask();
            
        } finally {
            // 4. 释放锁（无论任务是否成功，都要尝试释放）
            releaseLock(jedis, lockKey, clientId, renewFuture);
            System.out.println("释放锁完成");
            jedis.close();
        }
    }
    
    // 模拟核心任务（比如耗时20秒）
    private static void executeTask() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

// 获取分布式锁（可重入锁）
RLock lock = redisson.getLock("lock:stock");
try {
    // 尝试获取锁，最多等待10秒，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();