Redis Fundamentals: Pipelines, Pub/Sub, Expiration, Transactions, Persistence, Distributed Locks and Clustering

Redis is an in‑memory data store that offers high performance for caching and real‑time data processing. The article begins with a brief introduction to Redis basics and then explains how pipelines reduce round‑trip time by batching commands, improving throughput.

It describes the publish/subscribe model, where publishers send messages to channels and multiple subscribers receive them, illustrated with a multi‑client demo.

Key expiration is covered, including the EXPIRE command, the importance of setting TTLs to avoid memory bloat, and the active and passive expiration algorithms Redis uses to clean up expired keys.

Transaction semantics are explained: MULTI/EXEC/DISCARD/WATCH provide atomic execution, but Redis does not roll back on errors, which can lead to partial updates. Examples show error handling inside transactions.

Persistence mechanisms are detailed: RDB creates point‑in‑time snapshots via forked child processes, while AOF logs every write operation. The article compares their advantages and disadvantages, introduces hybrid persistence (AOF with RDB preamble), and shows configuration snippets such as appendonly yes and appendfsync everysec .

Distributed locking strategies are explored, starting with simple SETNX, then SETNX+EXPIRE, Lua scripts for atomic lock acquisition, and finally the robust Redisson implementation that auto‑extends lock TTLs. The Redlock algorithm for multi‑node clusters is outlined step‑by‑step.

High‑availability architectures are presented: master‑slave replication (read/write separation), Sentinel monitoring and automatic failover (including quorum voting and master election), and Redis Cluster with hash slots for horizontal scaling. Configuration examples for each mode are provided, along with commands to create a cluster ( redis-cli --cluster create 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 --cluster-replicas 1 ).

Finally, common cache pitfalls such as cache penetration, cache breakdown, cache avalanche, and cache pollution are defined and mitigated with techniques like empty‑value caching, Bloom filters, request throttling, distributed locks, staggered TTLs, and eviction policies.