Evolution of Distributed Locks with Redis and Redisson

Distributed locks are essential for ensuring that only one process executes a critical section in a distributed environment.

Basic principle: a process attempts to "occupy a spot" (e.g., using Redis SETNX) and either proceeds if successful or waits (spins) until the lock is released.

Stage 1 demonstrates a naive implementation where the lock is set with SETNX, the business logic runs, and the lock is deleted afterwards. If the process crashes before deleting, a deadlock occurs.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    //阶段一
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "111");
    //获取到锁，执行业务
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        //删除锁，如果在此之前报错或宕机会造成死锁
        stringRedisTemplate.delete("lock");
        return categoriesDb;
    } else {
        //没获取到锁，等待100ms重试
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonDbWithRedisLock();
    }
}

public Map<String, List<Catalog2Vo>> getCategoryMap() {
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    String catalogJson = ops.get("catalogJson");
    if (StringUtils.isEmpty(catalogJson)) {
        System.out.println("缓存不命中，准备查询数据库。。。");
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoriesDb();
        String toJSONString = JSON.toJSONString(categoriesDb);
        ops.set("catalogJson", toJSONString);
        return categoriesDb;
    }
    System.out.println("缓存命中。。。。");
    Map<String, List<Catalog2Vo>> listMap = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catalog2Vo>>>() {});
    return listMap;
}

Problem: lock may remain if the process crashes. Solution: set an automatic expiration on the lock.

Stage 2 adds an explicit expiration after acquiring the lock. However, if the process crashes between SETNX and setting the expiration, the lock can still deadlock.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "111");
    if (lock) {
        //设置过期时间
        stringRedisTemplate.expire("lock", 30, TimeUnit.SECONDS);
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        stringRedisTemplate.delete("lock");
        return categoriesDb;
    } else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonDbWithRedisLock();
    }
}

Solution: use the atomic SET command with EX option (SET key value EX ttl NX).

Stage 3 sets the expiration together with the lock acquisition, but still deletes the lock unconditionally, which can remove another process's lock if the original lock expires during a long business operation.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    //加锁的同时设置过期时间，二者是原子性操作
    Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111", 5, TimeUnit.SECONDS);
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        //模拟超长的业务执行时间
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stringRedisTemplate.delete("lock");
        return categoriesDb;
    } else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonDbWithRedisLock();
    }
}

Solution: store a unique UUID as the lock value and only delete the lock if the stored value matches the UUID.

Stage 4 implements the UUID check before deletion.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    String uuid = UUID.randomUUID().toString();
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    //为当前锁设置唯一的uuid，只有当uuid相同时才会进行删除锁的操作
    Boolean lock = ops.setIfAbsent("lock", uuid, 5, TimeUnit.SECONDS);
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        String lockValue = ops.get("lock");
        if (lockValue.equals(uuid)) {
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stringRedisTemplate.delete("lock");
        }
        return categoriesDb;
    } else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonDbWithRedisLock();
    }
}

Problem: the lock may expire after the UUID check but before deletion, causing a process to delete a lock owned by another client.

Solution: perform the check‑and‑delete atomically using a Lua script.

Stage 5 – Final form combines UUID, expiration, and an atomic Lua script to safely release the lock.

public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithRedisLock() {
    String uuid = UUID.randomUUID().toString();
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    Boolean lock = ops.setIfAbsent("lock", uuid, 5, TimeUnit.SECONDS);
    if (lock) {
        Map<String, List<Catalog2Vo>> categoriesDb = getCategoryMap();
        String lockValue = ops.get("lock");
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then
" +
                        "    return redis.call(\"del\",KEYS[1])
" +
                        "else
" +
                        "    return 0
" +
                        "end";
        stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), lockValue);
        return categoriesDb;
    } else {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonDbWithRedisLock();
    }
}

The article concludes with a brief introduction to Redisson, a Java client that builds on Redis to provide high‑level distributed objects and services such as distributed locks, semaphores, maps, queues, and more, simplifying the implementation of the patterns described above.