How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal

Business Background

Some business requests are time‑consuming and need locking to prevent concurrent operations and protect database data.

Analysis Process

Use Redis as a distributed lock, store lock state in Redis, define operation order, and protect data correctness.

Design Steps

Create annotation @RedisLockAnnotation to mark locked methods and specify the lock field.

Add AOP pointcut to scan the annotation.

Define @Aspect class to intercept methods, acquire lock with RedisTemplate.opsForValue().setIfAbsent, set expiration, and record the task in a queue.

Execute business logic via ProceedingJoinPoint.proceed().

In the finally block delete the key to release the lock.

Lock Acquisition

Use RedisTemplate.opsForValue().setIfAbsent(businessKey, uuid) and

RedisTemplate.expire(businessKey, lockTime, TimeUnit.SECONDS)

to obtain the lock.

Timeout Issue

If the protected method runs longer than the lock timeout, the key may expire early, allowing another thread to acquire the lock and cause data inconsistency.

Solution – Auto‑Renewal

Maintain a ScheduledExecutorService that runs every 2 seconds, scans a ConcurrentLinkedQueue of lock holders, extends the expiration when the remaining time is less than one‑third of the lock timeout, and interrupts the thread after a configured retry count.

private static final ScheduledExecutorService SCHEDULER =
    new ScheduledThreadPoolExecutor(1, new BasicThreadFactory.Builder()
        .namingPattern("redisLock-schedule-pool")
        .daemon(true)
        .build());

SCHEDULER.scheduleAtFixedRate(() -> {
    // iterate holders, extend or remove
}, 0, 2, TimeUnit.SECONDS);

Aspect Implementation

@Around("redisLockPC()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Method method = resolveMethod(pjp);
    RedisLockAnnotation ann = method.getAnnotation(RedisLockAnnotation.class);
    String businessKey = ann.typeEnum().getUniqueKey(pjp.getArgs()[ann.lockFiled()].toString());
    String uuid = UUID.randomUUID().toString();
    if (!redisTemplate.opsForValue().setIfAbsent(businessKey, uuid)) {
        throw new Exception("Lock already held");
    }
    redisTemplate.expire(businessKey, ann.lockTime(), TimeUnit.SECONDS);
    // add holder to queue for renewal
    Object result = pjp.proceed();
    return result;
} finally {
    redisTemplate.delete(businessKey);
    log.info("release the lock, businessKey is [" + businessKey + "]");
}

Testing

A controller method annotated with @RedisLockAnnotation demonstrates that when the lock timeout is exceeded, the thread is interrupted and the request fails, confirming that the lock works.

Conclusion

For time‑consuming operations that modify core data, a Redis‑based distributed lock with automatic renewal and thread interruption prevents duplicate concurrent processing and ensures data consistency.