Redis — 高性能内存数据库与缓存完全指南

# Ubuntu / Debian
sudo apt update && sudo apt install -y build-essential

# CentOS / RHEL
sudo yum groupinstall "Development Tools"

# 清理后重新编译
cd redis-stable
make distclean && make

# 查找占用进程
lsof -i :6379
# 或
ss -tlnp | grep 6379

# 终止占用进程
kill -9 <PID>

# 或者修改 Redis 端口
redis-server --port 6380

# 移除旧容器
docker rm -f redis

# 重新启动
docker run -d --name redis -p 6379:6379 redis:7-alpine

# 如果是其他原因退出，查看日志
docker logs redis

# 临时生效
echo 1 > /proc/sys/vm/overcommit_memory

# 永久生效
echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
sysctl -p

# 临时禁用
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag

# 永久禁用（添加到 rc.local 或 systemd service）
# /etc/rc.local
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag

# 临时调整
echo 1024 > /proc/sys/net/core/somaxconn

# 永久生效
echo "net.core.somaxconn = 1024" >> /etc/sysctl.conf
sysctl -p

# 创建 redis 用户
sudo useradd -r -s /sbin/nologin redis

# 设置目录权限
sudo chown -R redis:redis /var/lib/redis /var/log/redis /etc/redis

# 使用 systemd 服务管理（已内置用户切换）
sudo systemctl start redis

# 方案 1：清理后重新编译
make distclean
make

# 方案 2：使用 libc 分配器（不推荐生产环境）
make MALLOC=libc

# 检查并修复权限
sudo mkdir -p /var/log/redis /var/lib/redis
sudo chown redis:redis /var/log/redis /var/lib/redis

# 查看详细错误
sudo journalctl -u redis -n 50

# 确认 redis.conf 中的路径配置正确
# logfile "/var/log/redis/redis-server.log"
# dir "/var/lib/redis"

# 修改 redis.conf
bind 0.0.0.0    # 或指定内网 IP：bind 192.168.1.100

# 同时关闭保护模式（需配合密码使用）
protected-mode no

# 重启 Redis
sudo systemctl restart redis

# 命令行连接时指定密码
redis-cli -a your-password

# 或连接后认证
redis-cli
AUTH your-password

# 使用 URL 格式
redis-cli -u redis://:your-password@127.0.0.1:6379

# 查看当前连接数
redis-cli info clients

# 查看当前连接详情
redis-cli client list

# 增大最大连接数（redis.conf）
maxclients 50000

# 动态修改（无需重启）
redis-cli CONFIG SET maxclients 50000

# 排查连接泄漏（未关闭的空闲连接）
redis-cli client list | grep "idle=\|age="

# 推荐方案：设置密码
requirepass your-strong-password

# 或者同时做两件事（redis.conf）
bind 192.168.1.100          # 绑定内网 IP
requirepass your-password    # 设置密码
protected-mode yes           # 保持保护模式开启

# redis.conf 中配置 TLS
tls-port 6380
tls-cert-file /path/to/redis.crt
tls-key-file /path/to/redis.key
tls-ca-cert-file /path/to/ca.crt

# 客户端连接
redis-cli --tls --cert /path/to/client.crt --key /path/to/client.key --cacert /path/to/ca.crt -p 6380

# 查看当前用户权限
ACL WHOAMI
ACL GETUSER <username>

# 授予权限（管理员操作）
ACL SETUSER myuser +config on
ACL SAVE

# 或修改 ACL 配置文件
# aclfile /etc/redis/users.acl

# Java (Jedis) 连接池配置建议
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);          // 最大连接数
config.setMaxIdle(20);           // 最大空闲连接
config.setMinIdle(5);            // 最小空闲连接
config.setMaxWaitMillis(3000);   // 等待超时
config.setTestOnBorrow(true);    // 借用时测试连接

# 查看内存使用情况
redis-cli info memory

# 设置最大内存和淘汰策略
maxmemory 4gb
maxmemory-policy allkeys-lru   # 在所有 key 中 LRU 淘汰

# 常用淘汰策略：
# volatile-lru   — 仅对设置了过期时间的 key 进行 LRU 淘汰
# allkeys-lru    — 对所有 key 进行 LRU 淘汰（推荐缓存场景）
# volatile-ttl   — 淘汰 TTL 最小的 key
# allkeys-lfu    — 对所有 key 进行 LFU 淘汰（Redis 4.0+，推荐）
# noeviction     — 不淘汰，内存满时拒绝写入（默认）

# 查看碎片率
redis-cli info memory | grep mem_fragmentation_ratio

# Redis 4.0+ 开启自动碎片整理
CONFIG SET activedefrag yes

# 调整碎片整理参数
CONFIG SET active-defrag-threshold-lower 10    # 碎片率 > 10% 时开始整理
CONFIG SET active-defrag-threshold-upper 100   # 碎片率 > 100% 时全力整理
CONFIG SET active-defrag-cycle-min 1           # 最小 CPU 占比 1%
CONFIG SET active-defrag-cycle-max 25          # 最大 CPU 占比 25%

# 扫描大 Key
redis-cli --bigkeys

# 更精确的分析（Redis 4.0+）
redis-cli --memkeys

# 查看指定 key 的内存使用
redis-cli MEMORY USAGE mykey

# 解决方案：拆分大 Key
# 例：将一个 100 万元素的 Hash 拆分为 100 个子 Hash
# user:data → user:data:0, user:data:1, ..., user:data:99
# 分桶算法：bucket = CRC32(field) % 100

# 确保 overcommit_memory = 1
echo 1 > /proc/sys/vm/overcommit_memory

# 预留足够内存（建议 maxmemory 不超过物理内存的 50-60%）
# 例：8GB 服务器，maxmemory 设为 4gb

# 减少 fork 期间的写放大
# 禁用 THP
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 监控 COW 内存
redis-cli info persistence | grep rdb_last_cow_size

# 手动触发扫描（生产环境慎用）
redis-cli SCAN 0 COUNT 10000

# 调优定期删除频率（redis.conf）
hz 25   # 默认 10，增大可加快过期 key 回收（但增加 CPU）

# 避免大量 key 同时过期 — 给 TTL 加随机偏移
# TTL = base_ttl + random(0, 300)

# 检查 Redis 进程是否使用 Swap
cat /proc/$(pidof redis-server)/smaps | grep Swap

# 检查系统 Swap 使用
free -h
swapon --show

# 解决方案
# 1. 增加物理内存或降低 maxmemory
# 2. 降低 swappiness
echo 1 > /proc/sys/vm/swappiness

# 3. 生产环境建议完全禁用 Swap（确保内存充足）
swapoff -a

# 查看是否被 OOM Kill
dmesg | grep -i "oom\|kill"

# 调低 Redis 进程的 OOM 分数（降低被杀优先级）
echo -17 > /proc/$(pidof redis-server)/oom_adj

# 根本解决方案
# 1. 设置合理的 maxmemory（留出操作系统和 fork 所需内存）
# 2. 增加服务器内存
# 3. 使用淘汰策略而非 noeviction

# 使用 UNLINK 代替 DEL（异步删除）
UNLINK large_key

# 在 redis.conf 中开启 lazy-free
lazyfree-lazy-eviction yes       # 淘汰时异步释放
lazyfree-lazy-expire yes         # 过期时异步释放
lazyfree-lazy-server-del yes     # 内部删除时异步释放
lazyfree-lazy-user-del yes       # DEL 命令也异步（Redis 6.0+）
lazyfree-lazy-user-flush yes     # FLUSHDB/FLUSHALL 异步（Redis 6.2+）

# 查看内存诊断信息
redis-cli MEMORY DOCTOR

# 查看内存统计
redis-cli MEMORY STATS

# 重置峰值统计
redis-cli CONFIG RESETSTAT

# 如果碎片率高，参考 #22 开启碎片整理
# 如果是临时大数据操作导致，评估是否需要优化业务逻辑

# 临时允许写入（不推荐长期使用）
CONFIG SET stop-writes-on-bgsave-error no

# 排查 RDB 失败原因
# 1. 磁盘空间不足
df -h

# 2. 权限问题
ls -la /data/dump.rdb
chown redis:redis /data

# 3. 内存不足无法 fork
# 参考 #24 解决 fork 内存问题

# 手动触发 RDB 快照测试
redis-cli BGSAVE

# 1. 先备份
cp appendonly.aof appendonly.aof.bak

# 2. 使用修复工具
redis-check-aof --fix appendonly.aof

# 3. 对于 Redis 7+ 的 Multi-Part AOF
redis-check-aof --fix appendonlydir/appendonly.aof.1.incr.aof

# 4. 确认修复结果后重启 Redis
redis-server /etc/redis/redis.conf

# 手动触发 AOF 重写
redis-cli BGREWRITEAOF

# 检查 AOF 重写状态
redis-cli info persistence | grep aof

# 调整自动重写阈值
CONFIG SET auto-aof-rewrite-percentage 100
CONFIG SET auto-aof-rewrite-min-size 64mb

# 检查是否有大量写操作导致快速增长
redis-cli info stats | grep instantaneous_ops_per_sec

# 1. 临时关闭 AOF
CONFIG SET appendonly no

# 2. 重启 Redis（此时会加载 RDB）
redis-cli SHUTDOWN
redis-server /etc/redis/redis.conf

# 3. 重新开启 AOF
CONFIG SET appendonly yes
BGREWRITEAOF

# 检查 RDB 文件完整性
redis-check-rdb /data/dump.rdb

# 如果有备份，使用备份恢复
cp /backup/dump.rdb /data/dump.rdb

# 如果没有备份但有 AOF，切换到 AOF 加载
# 修改 redis.conf：appendonly yes
# 重启 Redis

# 预防措施：开启 RDB 校验
rdbchecksum yes

# 排查磁盘 I/O
iostat -x 1

# 解决方案
# 1. 使用 SSD 替换 HDD
# 2. AOF 重写期间跳过 fsync（牺牲少量安全性）
no-appendfsync-on-rewrite yes

# 3. 降低 fsync 频率（如果可以接受更多数据丢失风险）
appendfsync everysec   # 不要用 always

# 4. 将 AOF 目录放在高速磁盘上

# 查看详细原因
redis-cli info persistence | grep rdb_last_bgsave
dmesg | tail -20

# 常见原因和解决
# 1. OOM Killer 杀掉子进程 → 增加内存或降低 maxmemory
# 2. 磁盘空间不足 → 清理磁盘
# 3. /data 目录无写权限 → chown redis:redis /data

# 重新触发
redis-cli BGSAVE

# 确认配置
CONFIG GET aof-use-rdb-preamble   # 应返回 "yes"

# 手动触发 AOF 重写使配置生效
BGREWRITEAOF

# 验证：重写后的 AOF 文件开头是二进制 RDB 格式
# 可以用 file 命令检查
file appendonlydir/appendonly.aof.1.base.rdb

# 禁止在生产环境使用 KEYS！
# 使用 SCAN 替代（游标式迭代，不阻塞）
SCAN 0 MATCH "user:*" COUNT 100

# 通过 ACL 禁用 KEYS 命令
ACL SETUSER default -keys

# 或通过 rename-command 禁用
rename-command KEYS ""

# 配置慢查询阈值（微秒）
CONFIG SET slowlog-log-slower-than 10000   # 10ms
CONFIG SET slowlog-max-len 128

# 查看慢查询日志
SLOWLOG GET 10

# 查看慢查询数量
SLOWLOG LEN

# 重置
SLOWLOG RESET

# 常见慢查询原因：
# 1. O(N) 命令操作大集合（HGETALL、SMEMBERS、LRANGE 0 -1）
# 2. 大 Key 的 DEL 操作
# 3. Lua 脚本执行时间过长
# 4. SORT 命令排序大量数据

# 延迟基准测试
redis-cli --latency
redis-cli --latency-history
redis-cli --latency-dist

# Redis 内置延迟监控（Redis 2.8.13+）
CONFIG SET latency-monitor-threshold 5   # 记录 > 5ms 的事件
LATENCY LATEST
LATENCY HISTORY event-name

# 检查事件循环延迟
redis-cli DEBUG SLEEP 0   # 触发一次延迟检测

# 常见非命令延迟来源：
# 1. fork（BGSAVE/BGREWRITEAOF）
# 2. AOF fsync
# 3. 操作系统 Swap
# 4. 网络问题
# 5. 过期 key 的集中删除

# redis-cli 管道模式
cat commands.txt | redis-cli --pipe

# Python 示例
import redis
r = redis.Redis()
pipe = r.pipeline()
for i in range(10000):
    pipe.set(f"key:{i}", f"value:{i}")
pipe.execute()   # 一次性发送所有命令

# 注意事项：
# 1. Pipeline 不是原子操作（如需原子性用 MULTI/EXEC 或 Lua）
# 2. 单次 Pipeline 不要太大（建议 1000~10000 条）
# 3. Pipeline 中的命令结果在 execute() 后统一返回

# 发现热点 Key
redis-cli --hotkeys   # 需要开启 LFU 淘汰策略
redis-cli MONITOR     # 实时监控（短时间使用，影响性能）

# 解决方案
# 1. 本地缓存：在应用层增加 L1 缓存（如 Caffeine/Guava Cache）
# 2. 读写分离：将读请求分发到多个从节点
# 3. Key 拆分：将热点 Key 拆分为多个子 Key（如 hotkey:0 ~ hotkey:9）
#    读取时随机选择一个子 Key
# 4. 使用 Redis Cluster 的 READONLY 命令让从节点分担读请求

# 方案 1：缓存空值
# 查询数据库为空时，在 Redis 中缓存空值
SET user:999999 "" EX 300   # 缓存空值 5 分钟

# 方案 2：布隆过滤器（Redis Stack / RedisBloom）
# 将所有合法 ID 加入布隆过滤器
BF.ADD valid_users "user:1"
BF.ADD valid_users "user:2"

# 请求前先检查
BF.EXISTS valid_users "user:999999"   # 0 → 不存在，直接拒绝

# 方案 3：请求参数校验
# 在接入层拦截非法请求（如负数 ID、超长字符串等）

# 基础 TTL + 随机偏移（0~300 秒）
import random
ttl = 3600 + random.randint(0, 300)
r.setex(f"cache:{key}", ttl, value)

# 方案 1：互斥锁（分布式锁）
# 缓存未命中时，先获取锁，再查数据库，再写缓存
SET lock:cache:hotkey "1" NX EX 10
# 获取锁成功 → 查询 DB → 写入缓存 → 释放锁
# 获取锁失败 → sleep 后重试读缓存

# 方案 2：逻辑过期
# 缓存中存储过期时间字段，实际不设 Redis TTL
HSET cache:hotkey data "..." expire_at 1704067200
# 读取时判断 expire_at，过期则异步更新，返回旧数据

# 方案 3：预热
# 热点 key 过期前主动刷新

# 使用集群模式连接（自动处理重定向）
redis-cli -c -h 192.168.1.1 -p 6379

# 客户端库需启用集群模式
# Python: redis.RedisCluster(...)
# Java: JedisCluster / Lettuce cluster mode

# 查看槽分配
redis-cli -c cluster slots

# 如果频繁出现，检查集群是否正在 rebalance
redis-cli -c cluster info