如何使用Redis 实现分布式锁(含自动续期与安全释放)

SET lock:order:12345 "client_1" NX EX 10

-- KEYS[1] = lock key
-- ARGV[1] = client_id
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end

public boolean unlock(String lockKey, String clientId) {
    String script = 
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        " else " +
        "   return 0 " +
        " end";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText(script);
    redisScript.setResultType(Long.class);
    Long result = redisTemplate.execute(
        redisScript,
        Collections.singletonList(lockKey),
        clientId
    );
    return result != null && result == 1;
}

客户端A加锁（EX 30s）
     ↓
启动 Watchdog 线程（每10s检查一次）
     ↓
若锁仍存在且属于本客户端 → 执行 EXPIRE lock:xxx 30
     ↓
业务执行完成 → 取消续期 + 释放锁

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.24.1</version>
</dependency>

@Autowired
private RedissonClient redissonClient;
public void doBusiness() {
    RLock lock = redissonClient.getLock("lock:order:12345");
    try {
        // 尝试加锁，最多等待10秒，上锁后30秒自动解锁
        boolean res = lock.tryLock(10, 30, TimeUnit.SECONDS);
        if (res) {
            try {
                // 执行业务逻辑（可能耗时较长）
                System.out.println("Locked! Doing business...");
                Thread.sleep(25000); // 模拟长任务
            } finally {
                lock.unlock(); // 自动取消续期 + 安全释放
            }
        } else {
            System.out.println("Failed to acquire lock");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

public boolean tryLock(String lockKey, String clientId, int expireSeconds) {
    String result = redisTemplate.opsForValue()
        .setIfAbsent(lockKey, clientId, expireSeconds, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(result);
}

private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
private volatile boolean isLocked = false;
public void watchDog(String lockKey, String clientId, int expireSeconds) {
    isLocked = true;
    scheduler.scheduleAtFixedRate(() -> {
        if (isLocked) {
            // 只有当前客户端持有锁时才续期
            String current = redisTemplate.opsForValue().get(lockKey);
            if (clientId.equals(current)) {
                redisTemplate.expire(lockKey, expireSeconds, TimeUnit.SECONDS);
            }
        }
    }, expireSeconds / 3, expireSeconds / 3, TimeUnit.SECONDS);
}

String lockKey = "lock:order:12345";
String clientId = "client_" + Thread.currentThread().getId();
if (tryLock(lockKey, clientId, 30)) {
    try {
        watchDog(lockKey, clientId, 30); // 启动续期
        // 执行业务
    } finally {
        isLocked = false; // 停止续期
        unlock(lockKey, clientId); // 安全释放
    }
}

# 锁结构
lock:order:12345
  field: client_1
  value: 2   # 重入次数