Mastering Redis: From Caching Basics to Distributed Locks and Cluster Scaling

Common SQL Database Caching

SQL databases store data on disk and use internal caches to reduce I/O, but caching only helps when data has not changed.

Why Cache Middleware Is Needed

Cache reduces pressure on backend databases by storing hot data in memory.

Main Application Architecture

Clients first check the cache; if the data is present, it is returned directly. Otherwise, the request is forwarded to the database, and the result is written back to the cache for future accesses.

Differences Between Memcached and Redis

Simple data types only

No persistence

No master/slave replication

No sharding

Rich data types

Supports disk persistence

Supports master/slave replication

Supports sharding

Why Redis Is So Fast

Operates entirely in memory, giving O(1) access.

Single‑threaded event loop avoids context switches and lock contention.

Simple hash‑map data structure with O(1) lookup.

Uses non‑blocking I/O multiplexing (epoll/kqueue).

Redis Data Types

String

Binary‑safe up to 512 MB; can store any data including images.

Hash

Dictionary of string fields, ideal for representing objects.

List

Ordered collection (FIFO/LIFO); useful for recent‑message feeds.

Set

Unordered collection of unique elements; O(1) add/remove/contains.

Sorted Set

Elements sorted by a numeric score, enabling range queries.

Advanced Types

HyperLogLog for approximate counting and Geo for geospatial indexing.

Finding Keys with a Fixed Prefix

Method 1: KEYS pattern – returns all matching keys but can block the server.

Method 2: SCAN cursor MATCH pattern COUNT n – incremental, non‑blocking iteration.

Implementing a Distributed Lock with Redis

Acquire a lock atomically using SET key value NX EX seconds (or PX for milliseconds). Release the lock with DEL key. The older SETNX + EXPIRE approach can lose atomicity if the process crashes between the two commands.

Asynchronous Queue Patterns

1. Use a Redis List with RPUSH to enqueue and LPOP to dequeue (may require a sleep loop when empty).

2. Use BLPOP key [key …] timeout for a blocking pop that waits for items.

3. Use Pub/Sub for fan‑out messaging; however, messages are volatile and not persisted.

Persistence Mechanisms

RDB – snapshot of the entire dataset at configured intervals (SAVE/BGSAVE). Fast loading but may lose recent writes.

AOF – appends every write command to a log file. More durable but results in larger files; can be rewritten to compact.

Hybrid RDB‑AOF – combines periodic RDB snapshots with incremental AOF writes, offering fast recovery and durability.

Pipeline

Batch multiple commands in a single round‑trip to reduce latency; useful when commands are independent.

Redis Replication and High Availability

Master‑slave replication provides read scalability. Full sync uses a snapshot plus incremental updates; incremental sync streams new writes.

Redis Sentinel monitors masters and slaves, sends alerts, and performs automatic failover by promoting a slave to master.

Redis Cluster shards data across multiple nodes using consistent hashing, supporting horizontal scaling.

Consistent Hashing and Virtual Nodes

Keys are hashed onto a 2³² ring; each node occupies multiple points (virtual nodes) on the ring to balance load and minimize data skew when nodes are added or removed.