RedissonRedLock写一个加锁方式，实现自动延时、程序停止就停止延时

要使用 Redisson 的 RedLock 实现加锁，并实现自动延时以及在程序停止时停止延时，你可以按照以下示例代码进行操作：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

public class RedissonRedLockWithAutoRenewal {

    private static final long LEASE_TIME = 30 * 1000L; // 锁的过期时间，默认为 30 秒
    private static final long RENEWAL_INTERVAL = 10 * 1000L; // 自动续期的时间间隔，默认为 10 秒

    public static void main(String[] args) {
        Config config1 = new Config();
        config1.useSingleServer().setAddress("redis://127.0.0.1:6379");

        Config config2 = new Config();
        config2.useSingleServer().setAddress("redis://127.0.0.1:6380");

        Config config3 = new Config();
        config3.useSingleServer().setAddress("redis://127.0.0.1:6381");

        RedissonClient redissonClient1 = Redisson.create(config1);
        RedissonClient redissonClient2 = Redisson.create(config2);
        RedissonClient redissonClient3 = Redisson.create(config3);

        RLock lock1 = redissonClient1.getLock("lock:key");
        RLock lock2 = redissonClient2.getLock("lock:key");
        RLock lock3 = redissonClient3.getLock("lock:key");

        RLock[] locks = new RLock[]{lock1, lock2, lock3};

        // 获取锁并执行任务
        try {
            if (tryLock(locks)) {
                // 执行具体的业务逻辑

                // 启动自动续期任务
                startRenewalTask(locks);
            } else {
                // 获取锁失败，处理锁被其他程序占用的逻辑
            }
        } catch (InterruptedException e) {
            // 处理中断异常
        } finally {
            // 停止自动续期任务
            stopRenewalTask(locks);

            // 释放锁
            for (RLock lock : locks) {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }

            // 关闭 Redis 客户端
            redissonClient1.shutdown();
            redissonClient2.shutdown();
            redissonClient3.shutdown();
        }
    }

    private static boolean tryLock(RLock[] locks) throws InterruptedException {
        return RedissonRedLock.tryLock(locks, LEASE_TIME, TimeUnit.MILLISECONDS);
    }

    private static void startRenewalTask(RLock[] locks) {
        Thread renewalThread = new Thread(() -> {
            while (true) {
                try {
                    // 等待续期时间间隔
                    Thread.sleep(RENEWAL_INTERVAL);

                    // 续期
                    for (RLock lock : locks) {
                        lock.expire(LEASE_TIME, TimeUnit.MILLISECONDS);
                    }
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        renewalThread.setDaemon(true);
        renewalThread.start();
    }

    private static void stopRenewalTask(RLock[] locks) {
        for (RLock lock : locks) {
            lock.expire(0, TimeUnit.MILLISECONDS); // 立即释放锁
        }
    }
}

在这个示例中，我们使用了 Redisson 的 RedLock 实现，创建了三个 Redis 客户端和三个分布式锁对象。我们通过调用 RedissonRedLock.tryLock(locks, LEASE_TIME, TimeUnit.MILLISECONDS) 方法尝试获取分布式锁，如果成功获取到锁，则可以执行具体的业务逻辑。在获取到锁后，我们启动一个线程来定时进行续期操作，并在程序停止时停止续期任务。

当程序运行结束时，我们释放所有的锁，并关闭 Redis 客户端连接。

希望这个示例能够满足你的需求！