巧匠Developer Cheatsheet
Databases

Redis Slowdown Playbook: Big Keys, Blocking Commands and Eviction

Redis processes commands on a single thread, so one blocking hotspot slows the whole instance. This guide follows the order "memory level → big keys → blocking commands → eviction and persistence", each step with copy-ready commands.

By 巧匠 Team·8 min read·Updated 2026-08-30

Memory first: full or fragmented

`INFO memory` is the first stop: `used_memory_human` is actual usage and `maxmemory` the cap (0 means unlimited — dangerous, the OS OOM-killer will step in); a `mem_fragmentation_ratio` above 1.5 indicates fragmentation, common with frequent churn of large values.

When memory is full and the policy is noeviction, writes fail with OOM errors; the application symptom is "intermittent write failures", easily misdiagnosed as a network issue.

redis-cli INFO memory | grep -E "used_memory_human|maxmemory_human|mem_fragmentation"
redis-cli CONFIG GET maxmemory

Scan for big keys: the usual culprit

A ZSET with a million members can make one full ZRANGE take seconds, queuing every command behind it. Use `redis-cli --bigkeys` for a low-overhead sampled view of the largest key per type; for precise sizes use `--memkeys` (Redis 6.0+) or MEMORY USAGE per key.

Note that --bigkeys samples via the SCAN cursor and is safe to run in production; never use KEYS * — it walks the whole keyspace in one blocking shot and is a classic outage maker.

redis-cli --bigkeys          # 采样找各类型最大 key（安全）
redis-cli MEMORY USAGE <key>  # 精确测量单个 key

Read the slowlog: which command drags

The built-in slowlog records commands above a threshold (default 10ms; 1ms captures more clues). `SLOWLOG GET 10` shows the last ten — note the command name, latency and key, then trace the calling code.

The high-latency leaderboard: KEYS, SMEMBERS on big sets, HGETALL on big hashes, full ZRANGE, FLUSHALL/FLUSHDB, long loops in Lua. Replace each: KEYS → SCAN, SMEMBERS → batched SSCAN, HGETALL → HMGET of just the needed fields.

redis-cli CONFIG SET slowlog-log-slower-than 1000   # 阈值降到 1ms
redis-cli SLOWLOG GET 10

Eviction policy: the switch for when memory fills

For caches choose allkeys-lru (evict least-recently-used across the keyspace) or allkeys-lfu (hotter precision, 4.0+); for data that must persist choose noeviction, but then scale and alert in advance — write failures are only a matter of time. The volatile-* family only evicts keys with TTLs; if your keys have none, it behaves as noeviction.

Verify immediately after changing policy: push a write burst and confirm no OOM errors. Eviction bursts may add slight latency (many DELs); lazyfree (4.0+) makes deletion asynchronous.

redis-cli CONFIG SET maxmemory-policy allkeys-lru
redis-cli CONFIG SET lazyfree-lazy-eviction yes

Persistence jitter: RDB fork and AOF fsync

BGSAVE forks a child, and the fork cost grows with instance size (page-table copy), briefly stalling the main thread — for periodic stalls on big instances check latest_fork_usec in INFO stats. AOF everysec is the balanced default; switching to always fsyncs every write and collapses throughput.

If Redis is a pure cache with rebuildable data, turning persistence off (save "", appendonly no) removes an entire class of jitter — the most common "free" optimization.

redis-cli INFO stats | grep latest_fork_usec   # fork 耗时（微秒）

Emergency and prevention checklist

Live-incident flow: ① locate the command via SLOWLOG; ② delete big keys with UNLINK (async) instead of DEL; ③ restart non-critical instances if needed. Prevention: ① shard big collections into smaller keys; ② replace full traversal with SCAN cursors; ③ cap maxmemory at 70% of physical RAM; ④ monitor used_memory, slowlog count and replica lag. Paste this checklist into the on-call handbook and Redis MTTR drops by half.

redis-cli UNLINK <big-key>   # 异步删除，不阻塞主线程

More guides

Git Accident Recovery: Fix Wrong Commits, Wrong Branches and Deleted BranchesThe scariest moment in daily work is "oh no, I messed up a commit or branch". This guide gives copy-ready recovery commands for real accident scenarios, with clear safety boundaries for each.Docker Image Slimming: 5 Steps from 1.2GB to 120MBBigger images mean slower pulls, larger attack surface and higher storage cost. This guide gives 5 immediately applicable slimming steps, each with a reusable Dockerfile snippet and a verification command.Nginx 502 Bad Gateway? Locate It in 5 StepsA 502 means Nginx itself is fine but got an invalid response from the upstream (backend/proxy). This guide gives the shortest path: process → config → timeout → resources → logs.Linux Disk Full: Locate the Real Culprit with df, du and lsofA "No space left on device" error does not mean you should delete files at random. This guide walks through the full path — filesystem water level, directory drill-down, and "deleted but still held" files — plus a safe cleanup order that will not destroy data.Linux CPU at 100%: the Shortest Path from top to the Thread Stack"Restart fixes everything" is the most expensive option when CPU is pegged. This guide gives a reusable path: classify the load, pin the thread, capture what it is executing, then act — with dedicated tools for Java, Python and Go.MySQL Slow Query Tuning: Slow Log, EXPLAIN and Indexing"The database is slow" usually means a handful of slow SQL statements. This guide offers a repeatable flow: use the slow log to circle the most expensive queries, read the plan with EXPLAIN, decide whether an index pays off, and spot the most common index-defeating patterns.Kubernetes CrashLoopBackOff: Diagnose a Restart-Looping Pod in 5 StepsCrashLoopBackOff is not one error but a state: the container dies on start, and Kubernetes retries with backoff. This guide gives the shortest path — exit code → previous logs → probes → resources → dependencies.SSH Passwordless Login: from ssh-keygen to Permission deniedPasswordless SSH boils down to one sentence: put the public key into the remote authorized_keys. What blocks you is usually the three hidden gates — file permissions, the home directory, and SELinux. This guide covers the full setup and a step-by-step debugging path.Python Virtual Environments in Practice: venv, Dependency Pinning and Cross-Platform Gotchas"Works on my machine" usually means mixed environments. This guide builds a clean flow with the stdlib venv: create, activate, pin and reproduce — plus the three frequent pitfalls: Windows activation, version drift and cross-platform dependencies.VSCode Remote Development: Remote-SSH Setup and Connection DebuggingA weak laptop, code on an intranet server, GPUs in the cluster — Remote-SSH keeps the UI local while code and terminal run remotely, feeling native. This guide covers setup, passwordless auth, common connection failures and experience tuning.
← Back to Guides