A background defragmenter owns expired-key deletion and only runs when memory becomes fragmented.

It may still occupy memory because Redis expiration is partly lazy; cold keys can remain until active sampling finds them.

Expired keys are deliberately retained until the next RDB save so the snapshot stays consistent.

Reads of other keys in the same hash bucket refresh neighboring deadlines, silently extending the key's TTL, a side effect of how the shared bucket metadata gets updated.

They should agree on physical deletion, with all three observing that the memory has already been freed.

GET and EXISTS should agree the key is gone, but recovery may resurrect it briefly until the first access.

They only need to agree on the TTL value itself; whether the key is visible may differ per code path.

They should agree that the key is logically gone once its absolute deadline has passed.

Absolute timestamps are smaller to store than relative TTLs, which keeps persistence files compact.

Relative TTLs are unsafe because clients cannot compute them; only the server clock can be trusted.

Absolute timestamps survive downtime correctly, while relative TTLs can accidentally restart the countdown after persistence or recovery.

Absolute timestamps let replicas expire keys on their own schedule, improving availability when the primary becomes unreachable during a failover.

Passive expiration is cheap and precise for accessed keys but misses cold keys; active expiration costs background work and is approximate but covers cold keys.

Active expiration is precise and free because it runs in idle time, while passive expiration adds latency to every read.

Passive expiration eventually covers all keys because every key is read eventually; the active cycle exists only for metrics.

They differ only in their trigger; both scan the whole expires dictionary, so cost and coverage are identical.

Handlers should each check expiration themselves, so they can customize TTL behavior per command — GETEX-style commands prove per-command TTL behavior is sometimes wanted.

Expiration belongs only in the active cycle, and lookups should trust the keyspace to already be clean.

Expiration belongs in the RESP layer, which can filter out replies that mention expired keys.

Shared lookup logic keeps every read and existence check consistent, instead of relying on each command handler to remember expiration rules.