Mastering Redis: From Core Data Types to Enterprise‑Scale Distributed Locks

Redis (Remote Dictionary Server) is a high‑performance in‑memory key‑value store often used as a cache layer to accelerate applications. It supports various data structures including strings, hashes, lists, sets, sorted sets, bitmaps, geospatial indexes, streams, and HyperLogLog.

Data Types

String : basic type, max size 512 MB per key.

Hash : dictionary‑like, up to 2^32‑1 fields.

List : ordered collection of strings, up to 2^32‑1 elements.

Set : unordered unique strings.

Sorted Set : ordered by a score, useful for ranking.

Bitmap : binary‑bit operations.

Geospatial : stores latitude/longitude, supports radius queries.

Stream (Redis 5.0+): message‑oriented data structure.

HyperLogLog : cardinality estimation.

Persistence

Redis offers two persistence methods to avoid data loss:

RDB (Redis DataBase) : snapshotting – writes the dataset to disk at configured intervals.

AOF (Append‑Only File) : logs every write command and replays them on recovery.

RDB advantages: compact file, fast backup/restore, minimal impact on the main process because it forks a child for saving. RDB drawbacks: potential data loss of a few minutes and fork overhead for large datasets.

AOF advantages: can recover from accidental commands (e.g., FLUSHALL) by editing the AOF before restart; provides near‑real‑time durability (default fsync every second). AOF drawbacks: larger file size and slower recovery compared to RDB.

Enterprise Persistence Configuration

Typical settings for production Redis clusters: save 60 10000 – snapshot if 10 000 writes occur within 60 seconds. appendonly yes and appendfsync everysec – enable AOF with per‑second fsync. auto-aof-rewrite-percentage 100 – trigger AOF rewrite when size doubles. auto-aof-rewrite-min-size 64mb – minimum size before rewrite.

Common Business Use Cases

Hash sets for follow lists, fan lists, mutual follows.

String counters for article reads, follower counts.

Sorted sets for hot topics, leaderboards.

Lists as queues for push/sub notifications.

Geospatial queries for nearby users or services.

Bitmap for massive‑scale presence or deduplication.

In practice, limiting data types to three or fewer and using integer storage can dramatically reduce memory consumption (e.g., 2 billion items stored as 4‑byte integers require ~16 GB).

Distributed Lock with Redisson

Redisson implements a distributed lock using Redis commands and Lua scripts. The lock acquisition flow:

Execute a Lua script that creates a lock key with SETNX and sets an expiration.

If the lock already exists and the caller owns it, increment a re‑entrancy counter.

If acquisition fails, subscribe to a Pub/Sub channel for unlock notifications.

Block on a semaphore until the lock is released or the wait timeout expires.

Periodically renew the lock expiration (the “watchdog”) to avoid accidental expiry while the holder is still active.

Unlocking runs another Lua script that decrements the re‑entrancy counter, deletes the key when it reaches zero, and publishes an unlock message to wake waiting clients.

Key Lua Scripts

-- Acquire lock
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hset', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
return redis.call('pttl', KEYS[1]);

-- Release lock
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end;
if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then
    return nil;
end;
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;

The watchdog task runs every internalLockLeaseTime/3 (≈10 seconds for the default 30 s lease) and extends the lock expiration as long as the holder is alive.

Redis Transactions

Redis supports atomic multi‑command execution via MULTI/EXEC, Lua scripting, and pipelining, enabling safe updates in high‑concurrency environments.

Conclusion

Redis combines rich data structures, flexible persistence, and powerful distributed synchronization primitives. Understanding its core types, configuring RDB/AOF appropriately, and leveraging libraries like Redisson for reliable locks allow developers to build scalable, high‑performance services across a wide range of business scenarios.