// 初始化看門狗線程
private void startWatchdog() {
    // 每隔10秒檢查一次鎖的狀態(tài)
    long delay = 10 * 1000;
    watchdogFuture = scheduler.scheduleWithFixedDelay(() -> {
        try {
            // 檢查當(dāng)前持有的鎖
            checkAndExtendLocks();
        } catch (Exception e) {
            // 處理異常
            handleWatchdogException(e);
        }
    }, delay, delay, TimeUnit.MILLISECONDS);
}

// 檢查并延長(zhǎng)鎖的過期時(shí)間
private void checkAndExtendLocks() {
    for (RLock lock : locks) {
        if (lock.isHeldByCurrentThread()) {
            // 更新鎖的過期時(shí)間
            lock.extendLeaseTime();
        }
    }
}

// 更新鎖的過期時(shí)間
private void extendLeaseTime() {
    String script = "if redis.call('exists', KEYS[1]) == 1 then " +
                    "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                    "return 1; " +
                    "else " +
                    "return 0; " +
                    "end";
    // 執(zhí)行Redis腳本，更新鎖的過期時(shí)間
    redisTemplate.execute(new DefaultRedisScript<>(script, Integer.class), Collections.singletonList(lockKey), leaseTime);
}

@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    long time = unit.toMillis(waitTime);
    long leaseTimeInMillis = unit.toMillis(leaseTime);
    long currentTime = System.currentTimeMillis();
    long lockExpireTime = currentTime + leaseTimeInMillis;

    String lockValue = UUID.randomUUID().toString();
    boolean acquired = tryAcquireLock(lockValue, leaseTimeInMillis);

    if (!acquired && time > 0) {
        long endTime = currentTime + time;
        while (System.currentTimeMillis() < endTime) {
            acquired = tryAcquireLock(lockValue, leaseTimeInMillis);
            if (acquired) {
                break;
            }
            Thread.sleep(10); // Retry interval
        }
    }

    if (acquired) {
        scheduleExpirationRenewal(lockValue, leaseTimeInMillis);
    }

    return acquired;
}

private boolean tryAcquireLock(String lockValue, long leaseTimeInMillis) {
    String script = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
                    "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                    "return 1; " +
                    "else " +
                    "return 0; " +
                    "end";
    List<Object> keys = Collections.singletonList(lockKey);
    List<Object> args = Arrays.asList(lockValue, leaseTimeInMillis);
    Long result = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), keys, args);

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

private void scheduleExpirationRenewal(String lockValue, long leaseTimeInMillis) {
    long delay = leaseTimeInMillis / 3;
    scheduler.scheduleWithFixedDelay(() -> {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                        "end";
        List<Object> keys = Collections.singletonList(lockKey);
        List<Object> args = Arrays.asList(lockValue, leaseTimeInMillis);
        redisTemplate.execute(new DefaultRedisScript<>(script, Void.class), keys, args);
    }, delay, delay, TimeUnit.MILLISECONDS);
}

Config config = new Config();
config.useSingleServer()
      .setAddress("redis://127.0.0.1:6379")
      .setWatchdogTimeout(30000); // 將看門狗超時(shí)時(shí)間設(shè)置為30秒
RedissonClient redissonClient = Redisson.create(config);

String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                "return redis.call('expire', KEYS[1], ARGV[2]) " +
                "else return 0 end";
redisClient.eval(script, Collections.singletonList("myLock"), Arrays.asList("lockValue", "30"));

// 示例：使用Prometheus進(jìn)行監(jiān)控
@Autowired
private MeterRegistry meterRegistry;

public void monitorWatchdog() {
    meterRegistry.gauge("redisson_watchdog_status", redissonClient.getLock("myLock").isLocked() ? 1 : 0);
}

public class WatchdogBackup implements Runnable {
    private final RedissonClient redissonClient;

    public WatchdogBackup(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public void run() {
        RLock lock = redissonClient.getLock("myLock");
        while (true) {
            if (!lock.isLocked()) {
                System.out.println("Watchdog stopped, acquiring lock...");
                lock.lock();
            }
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public void startBackupWatchdog(RedissonClient redissonClient) {
    Thread backupThread = new Thread(new WatchdogBackup(redissonClient));
    backupThread.setDaemon(true);
    backupThread.start();
}

public void startRedundantWatchdogs(RedissonClient redissonClient) {
    for (int i = 0; i < 3; i++) {
        Thread watchdogThread = new Thread(new WatchdogBackup(redissonClient));
        watchdogThread.setDaemon(true);
        watchdogThread.start();
    }
}