How does Redis manage memory?

Question

Accepted Answer

Since Redis stores data in RAM, **memory management** is critical — understanding the `maxmemory` limit, **eviction policies**, memory optimization, and monitoring is essential for running Redis reliably without running out of memory.

## maxmemory and eviction

```text
Set a memory limit so Redis doesn't consume all RAM:
  maxmemory 2gb                       # cap Redis at 2GB
  maxmemory-policy allkeys-lru        # what to do when the limit is reached

When the limit is hit, Redis EVICTS keys per the policy (or rejects writes):
  allkeys-lru   → evict least-recently-used (any key) — common for a pure cache
  allkeys-lfu   → evict least-frequently-used
  volatile-lru  → evict LRU among keys WITH a TTL only
  volatile-ttl  → evict keys closest to expiry
  noeviction    → reject writes when full (good if Redis holds important data)
```

Setting `maxmemory` plus an **eviction policy** controls behavior when memory fills — essential to prevent Redis from exhausting system memory or crashing.

## Monitoring memory

```bash
INFO memory               # used_memory, peak, fragmentation ratio, etc.
MEMORY USAGE key          # memory used by a specific key
MEMORY DOCTOR             # diagnostics/recommendations
DBSIZE                    # number of keys
# watch: used_memory vs maxmemory, evicted_keys, fragmentation
```

## Memory optimization techniques

```text
✓ Set TTLs → expire data that's no longer needed (don't let data accumulate forever)
✓ Use efficient data structures → small hashes/lists/sets use compact encodings (ziplist/
  listpack) → much less memory than many separate keys
✓ Shorter key names (minor, but adds up at scale)
✓ Store only what you need; consider compression for large values
✓ Avoid huge keys (a single huge value/collection) — they cause latency spikes
```

## Why memory matters in Redis

```text
RAM is LIMITED and more expensive than disk. Running out of memory →
  evictions (cache misses), rejected writes, or crashes.
→ Capacity planning, eviction policy, TTLs, and monitoring keep Redis healthy.
```

## Why it matters

Understanding Redis memory management is important for **running Redis reliably**, because Redis stores data in limited, relatively expensive RAM, so managing memory is essential to prevent it from running out (causing evictions, rejected writes, or crashes).

The foundational practice — setting **`maxmemory`** (capping Redis's memory) plus an **eviction policy** — is critical: it controls what happens when the limit is reached (evicting keys per policies like `allkeys-lru` for a pure cache, or `noeviction` to reject writes when Redis holds important data), preventing Redis from exhausting system memory.

Choosing the right eviction policy for the use case (LRU/LFU for caches, noeviction or volatile policies when data matters) is key configuration judgment. **Monitoring memory** (`INFO memory` for usage, peak, fragmentation, and evicted-keys; `MEMORY USAGE` per key) is essential for operational awareness — watching usage against the limit and catching problems.

Knowing **memory optimization techniques** — using TTLs to expire unneeded data, choosing efficient data structures (small hashes/lists use compact encodings, far cheaper than many separate keys), avoiding huge keys (which cause latency spikes), and storing only what's needed — helps fit more in memory and run efficiently.

Since Redis's in-memory nature makes memory a finite, critical resource, and since proper memory management (maxmemory + eviction policy, monitoring, and optimization) is what keeps Redis healthy and prevents out-of-memory failures, understanding Redis memory management is important, practically-relevant knowledge for operating Redis reliably, a key operational concern that distinguishes those who can run Redis in production from those who only know how to use it, and essential for avoiding the real failures that come from unmanaged memory growth.