How to Build Safe Distributed Locks with Redis and Redisson

Preface

In everyday development we often need to lock resources, such as decrementing product inventory. The naive approach of reading the stock, checking it, and then decreasing it is not atomic and can cause overselling under concurrency. In a monolithic system a local lock may suffice, but a distributed system requires a distributed lock.

Solution

Using SETNX and EXPIRE

SETNX key value
EXPIRE key seconds
DEL key
if (setnx("item_1_lock",1)) {
    expire("item_1_lock",30);
    try {
        // business logic
    } catch {
        // handle error
    } finally {
        del("item_1_lock");
    }
}

This method can work but is risky because SETNX and EXPIRE are not atomic; if an error occurs after SETNX succeeds, the lock may never expire, leading to a deadlock.

Atomicity with Lua script

if (redis.call('setnx', KEYS[1], ARGV[1]) < 1) then
    return 0;
end;
redis.call('expire', KEYS[1], tonumber(ARGV[2]));
return 1;

Running SETNX and EXPIRE in a Lua script guarantees that both commands succeed or both fail, eliminating the deadlock risk.

SET command (Redis 2.6.12+)

SET key value NX EX 30
DEL key
if (set("item_1_lock",1,"NX","EX",30)) {
    try {
        // business logic
    } catch {
        // handle error
    } finally {
        del("item_1_lock");
    }
}

From Redis 2.6.12 onward the SET command can combine the lock acquisition and expiration atomically.

Getting Started with Redisson

Redisson provides a re‑entrant lock with automatic lease renewal. By adding the Redisson dependency you can use its high‑level API instead of writing raw Redis commands.

Install Redisson

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

implementation 'org.redisson:redisson:3.13.2'

Simple Example

RedissonClient redissonClient = Redisson.create();
RLock lock = redissonClient.getLock("lock");
boolean res = lock.lock();
if (res) {
    try {
        // business logic
    } finally {
        lock.unlock();
    }
}

Lock Implementation Details (selected snippets)

private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
    long threadId = Thread.currentThread().getId();
    Long ttl = tryAcquire(leaseTime, unit, threadId);
    if (ttl == null) return;
    // subscription handling omitted for brevity
    // repeat acquisition while needed
}

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    return evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
        "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil; " +
        "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
        "if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; " +
        "else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end;",
        Arrays.asList(getName(), getChannelName()), internalLockLeaseTime, getLockName(threadId));
}

Conclusion

Using Redis for distributed locking solves many concurrency problems but still has pitfalls such as non‑atomic operations and accidental lock deletion. Choose the appropriate technique (Lua script, SET with NX/EX, or Redisson) based on system scale and requirements, and remember that database‑level safeguards are also essential.