Beyond Caching: Real‑World Redis Use Cases and Scenarios

1. Redis as a Storage Engine

Redis offers multiple cluster modes— master‑slave, sentinel, and cluster —to satisfy high‑availability requirements. It provides two persistence mechanisms, AOF and RDB, with RDB being the most commonly used. The bgsave command creates a snapshot by forking a child process; because it lacks WAL and checkpointing, sudden power loss can cause data loss. However, as an in‑memory database, Redis can achieve very fast master‑slave synchronization, and with proper cluster management and memory allocation, its SLA remains high unless a data‑center outage occurs.

Before fully embracing Redis as a database, verify that the workload meets three conditions:

Data is user‑centric (e.g., identified by a user ID), the dataset per user is small, and range queries are rare.

The cost of keeping data in memory is acceptable.

Transactional requirements are minimal.

These characteristics are common in social, gaming, and live‑streaming services, making Redis a viable primary store for many internet companies.

2. Redis Application Scenarios

2.1 Basic User Data Storage

Redis hash structures enable a flexible schema for user profiles. Attributes can be stored as JSON strings inside the hash value, and commands like HGET and HMGET retrieve only the needed fields.

>HSET user:199929 sex m
>HSET user:199929 age 22
>HGETALL user:199929
1) "sex"
2) "m"
3) "age"
4) "22"

Hashes are ideal for read‑heavy, write‑light scenarios; the HINCRBY command can increment numeric fields directly.

2.2 Implementing Counters

The INCRBY command (or HINCRBY for hashes) provides atomic increment/decrement of a key’s value, useful for likes, follows, tag fans, comment counts, hotness scores, etc.

> INCRBY feed:e3kk38j4kl:like 1
> INCRBY feed:e3kk38j4kl:like 1
> GET feed:e3kk38j4kl:like
"2"

These operations execute in milliseconds, far faster than traditional DB COUNT queries.

2.3 Leaderboards

Redis zset (sorted set) uses a skip‑list implementation to maintain ordered scores. Even with tens of millions of members, reads and writes stay under 5 ms.

>ZADD sorted:xjjdog:2021-07 55 dog0
>ZADD sorted:xjjdog:2021-07 89 dog1
>ZADD sorted:xjjdog:2021-07 32 dog2
>ZCARD sorted:xjjdog:2021-07
3
>ZREVRANGE sorted:xjjdog:2021-07 0 -10 WITHSCORES
1) "dog1"
2) "89"
3) "dog0"
4) "55"
5) "dog2"
6) "32"

ZREVRANK

returns a user’s real‑time rank.

2.4 Friend Relationships

Sets store unique members such as follow lists, fan lists, blacklists, or likes. Using ZADD and ZRANK (or SINTER for intersection) enables fast friendship queries and blacklist checks.

2.5 Active‑User Statistics

Bitmaps efficiently record boolean flags for massive user IDs. Commands like SETBIT, GETBIT, and BITOP allow space‑saving active‑user tracking.

>SETBIT online:2021-07-23 3876520333 1
>SETBIT online:2021-07-24 3876520333 1
>GETBIT online:2021-07-23 3876520333
1
>BITOP AND active online:2021-07-23 online:2021-07-24
>GETBIT active 3876520333
1

Large IDs should be pre‑processed to avoid excessive memory consumption.

2.6 Distributed Locks

Redis can implement lightweight locks with SET using NX and PX options. A simple Java example:

public String lock(String key, int timeOutSecond) {
    for (;;) {
        String stamp = String.valueOf(System.nanoTime());
        boolean exist = redisTemplate.opsForValue().setIfAbsent(key, stamp, timeOutSecond, TimeUnit.SECONDS);
        if (exist) {
            return stamp;
        }
    }
}
public void unlock(String key, String stamp) {
    redisTemplate.execute(script, Arrays.asList(key), stamp);
}

The corresponding Lua script for safe unlock:

local stamp = ARGV[1]
local key = KEYS[1]
local current = redis.call("GET",key)
if stamp == current then
    redis.call("DEL",key)
    return "OK"
end

Redisson’s RedLock adds read/write lock semantics and handles multi‑instance failures.

2.7 Distributed Rate Limiting

A basic limiter increments a counter and sets an expiration:

incr key
expire key 1

For high traffic, fixed‑window limits can cause spikes; a sliding‑window approach is preferable. Redisson’s RRateLimiter offers a Guava‑like API:

RRateLimiter limiter = redisson.getRateLimiter("xjjdogLimiter");
// initialize once
limiter.trySetRate(RateType.OVERALL, 5, 2, RateIntervalUnit.SECONDS);
// acquire permits (blocks if unavailable)
limiter.acquire(3);

2.8 Message Queues

Lists implement simple queues with LPUSH (producer) and RPOP or BRPOP (consumer). PUB/SUB supports broadcast messaging. Redis 5.0 introduced stream, offering Kafka‑like topics and consumer groups.

2.9 Geospatial (LBS) Services

Since Redis 3.2, the GEOADD command stores latitude/longitude pairs, enabling distance calculations, radius queries, and nearby‑user features. For large‑scale GIS, PostGIS is stronger, but Redis suffices for typical use cases.

2.10 Extended Data Structures via Redisson

Redisson (Java client) wraps Redis primitives into rich distributed collections such as Set, SortedSet, Map, List, Queue, etc. The source tree (https://github.com/redisson/redisson/tree/master/redisson/src/main/java/org/redisson/api) lists over a hundred structures, enabling thread‑safe, high‑concurrency applications.

Common patterns include using Redis as a configuration center, storing JWT tokens for secure logout, or sharing static data across services.

3. Challenges of an All‑In‑One Redis Architecture

3.1 High‑Availability Challenges

Redis clusters map keys to 16 384 slots, which simplifies sharding but raises maintenance costs; slaves cannot serve reads. Batch operations like MGET, HMSET, or SUNION suffer performance penalties because keys may reside on different nodes. Master‑slave failover requires application‑level handling; adding HA proxies (e.g., HAProxy) increases complexity. Sentinel clusters monitor many nodes but are difficult to operate.

3.2 Hot‑Cold Data Separation

Storing all data in memory inflates costs for workloads with clear hot‑cold partitions. Middleware can route cold data to slower stores while keeping recent active users in Redis. The application code continues to use Redis APIs, abstracting away the underlying storage.

3.3 Functional Demands

Modules like RediSearch provide full‑text search capabilities, complementing Elasticsearch. For analytics, Redis RDB snapshots can be parsed (e.g., with redis‑rdb‑tools) and imported into Hadoop or other big‑data platforms. Thus Redis can act as both a fast operational store and a data exchange hub.

4. Summary

Redis powers a large portion of modern internet services, especially those with user‑centric, key‑based access patterns and modest data volumes. It excels at rapid development and iteration, but it is not a replacement for relational databases when large result sets, complex joins, or strict ACID guarantees are required. Selecting the right tool for the right scenario remains essential.