Redis 性能优化与运维

HSXISAWD2026/3/20大约 11 分钟

Redis 性能优化与运维

一、性能基准与瓶颈分析

1.1 Redis 性能基准

Redis 的理论性能：

指标	数值
QPS（简单命令）	10W+/s
QPS（复杂命令）	1W+/s
读写延迟	微秒级（<1ms）
网络带宽	可达 1GB/s

1.2 性能测试工具

# 使用 redis-benchmark 进行性能测试
redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 100000

# 参数说明：
# -c: 并发连接数
# -n: 请求总数
# -d: SET/GET 数据大小（字节）
# -t: 测试的命令（ping,set,get,incr,lpush...）
# -q: 简洁输出
# -P: Pipeline 数量

# 测试 SET 命令
redis-benchmark -h 127.0.0.1 -p 6379 -t set -c 100 -n 100000 -d 100

# 测试 Pipeline
redis-benchmark -h 127.0.0.1 -p 6379 -t set -c 100 -n 100000 -P 16

# 测试 Lua 脚本
redis-benchmark -h 127.0.0.1 -p 6379 --eval "return redis.call('set','key','value')"

1.3 性能瓶颈分析

二、命令优化

2.1 避免慢命令

# 危险命令（生产环境禁用或重命名）
KEYS *          # 遍历所有 key，O(N)
FLUSHALL        # 清空所有数据库
FLUSHDB         # 清空当前数据库
CONFIG          # 查看/修改配置

# 配置重命名
rename-command KEYS ""
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_b840fc02"

# 替代方案
# KEYS -> SCAN（分批遍历）
SCAN 0 MATCH "user:*" COUNT 100

2.2 使用 SCAN 替代 KEYS

public Set<String> scanKeys(String pattern) {
    Set<String> keys = new HashSet<>();

    ScanOptions options = ScanOptions.scanOptions()
            .match(pattern)
            .count(100)
            .build();

    try (Cursor<byte[]> cursor = redisTemplate.getConnectionFactory()
            .getConnection().scan(options)) {
        while (cursor.hasNext()) {
            keys.add(new String(cursor.next()));
        }
    }

    return keys;
}

2.3 使用 Pipeline 批量操作

// 不使用 Pipeline：100 次网络往返
for (int i = 0; i < 100; i++) {
    redisTemplate.opsForValue().set("key:" + i, "value:" + i);
}

// 使用 Pipeline：1 次网络往返
redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
    for (int i = 0; i < 100; i++) {
        connection.set(("key:" + i).getBytes(), ("value:" + i).getBytes());
    }
    return null;
});

2.4 使用 Lua 脚本

// 原子操作：检查并设置
String luaScript =
        "local current = redis.call('get', KEYS[1]) " +
        "if current == ARGV[1] then " +
        "    redis.call('set', KEYS[1], ARGV[2]) " +
        "    return 1 " +
        "else " +
        "    return 0 " +
        "end";

DefaultRedisScript<Long> script = new DefaultRedisScript<>();
script.setScriptText(luaScript);
script.setResultType(Long.class);

Long result = redisTemplate.execute(script,
        Collections.singletonList("key"),
        "expectedValue", "newValue");

2.5 合理使用数据结构

# 存储对象：Hash 比 String 更灵活
# String 方式
SET user:1001 '{"name":"张三","age":25,"email":"test@example.com"}'

# Hash 方式（推荐）
HSET user:1001 name "张三" age 25 email "test@example.com"

# 计数器：使用 INCR 而不是 GET + SET
# 错误
GET counter
SET counter (value + 1)

# 正确
INCR counter

# 排行榜：使用 Sorted Set
ZADD ranking 100 user1 200 user2 150 user3
ZREVRANGE ranking 0 9 WITHSCORES

三、内存优化

3.1 控制 Key 的大小

# Key 命名规范
# 推荐：简短、有意义、使用分隔符
user:1001:info
product:2001:stock

# 避免：过长的 key
very_very_very_long_key_name_for_user_information_storage_12345

# Key 长度建议不超过 44 字节（embstr 编码阈值）

3.2 控制 Value 的大小

# 避免大 key
# 单个 String value 不超过 10KB
# Hash、List、Set、ZSet 元素数不超过 5000

# 发现大 key
redis-cli --bigkeys

# 更详细的分析
redis-cli --memkeys

# 分析 RDB 文件
rdb --command memory dump.rdb --bytes 10240

3.3 使用压缩列表

# 配置压缩列表阈值
# Hash
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# List（Redis 3.2+ 使用 quicklist）
list-max-ziplist-size -2
list-compress-depth 0

# Set（只对整数有效）
set-max-intset-entries 512

# Sorted Set
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

3.4 设置合理的过期时间

// 所有缓存数据都应该设置过期时间
public void setWithExpire(String key, Object value, long expireSeconds) {
    // 添加随机偏移，避免缓存雪崩
    long randomOffset = ThreadLocalRandom.current().nextLong(0, expireSeconds / 10);
    redisTemplate.opsForValue().set(key, value,
            expireSeconds + randomOffset, TimeUnit.SECONDS);
}

3.5 定期清理过期数据

# 查看过期策略配置
CONFIG GET maxmemory-policy

# 推荐配置
maxmemory-policy allkeys-lru

# 监控过期 key 数量
INFO stats | grep expired_keys

四、网络优化

4.1 连接池配置

@Configuration
public class RedisConfig {

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        // 连接池配置
        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(100);       // 最大连接数
        poolConfig.setMaxIdle(50);         // 最大空闲连接
        poolConfig.setMinIdle(10);         // 最小空闲连接
        poolConfig.setMaxWaitMillis(3000); // 获取连接最大等待时间
        poolConfig.setTestOnBorrow(true);  // 借出时检测
        poolConfig.setTestWhileIdle(true); // 空闲时检测

        LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig)
                .commandTimeout(Duration.ofSeconds(3))
                .build();

        RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration();
        serverConfig.setHostName("localhost");
        serverConfig.setPort(6379);
        serverConfig.setPassword(RedisPassword.of("password"));

        return new LettuceConnectionFactory(serverConfig, clientConfig);
    }
}

4.2 TCP 优化

# Redis 配置
tcp-backlog 511         # TCP 连接队列长度
tcp-keepalive 300       # TCP keepalive

# Linux 系统配置
# /etc/sysctl.conf
net.core.somaxconn = 1024
net.ipv4.tcp_max_syn_backlog = 1024
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 300

4.3 本地缓存 + Redis

@Configuration
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(LettuceConnectionFactory connectionFactory) {
        // 本地缓存（Caffeine）
        CaffeineCacheManager localCacheManager = new CaffeineCacheManager();
        localCacheManager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(10000)
                .expireAfterWrite(5, TimeUnit.MINUTES));

        // Redis 缓存
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                        .entryTtl(Duration.ofHours(1)))
                .build();

        // 组合缓存管理器
        return new CompositeCacheManager(localCacheManager, redisCacheManager);
    }
}

五、持久化优化

5.1 RDB 优化

# 调整自动保存频率
save 900 1
save 300 100
save 60 10000

# 禁用 RDB（如果使用 AOF）
# save ""

# 后台保存失败时停止写入
stop-writes-on-bgsave-error yes

# RDB 文件压缩
rdbcompression yes

# RDB 文件校验
rdbchecksum yes

5.2 AOF 优化

# 开启 AOF
appendonly yes

# 同步策略
appendfsync everysec

# 重写期间禁止 fsync（提高性能，但可能丢数据）
no-appendfsync-on-rewrite no

# 自动重写条件
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 使用混合持久化（Redis 4.0+）
aof-use-rdb-preamble yes

5.3 Fork 优化

# 监控 fork 耗时
redis-cli INFO stats | grep latest_fork_usec

# 优化建议：
# 1. 使用 SSD 磁盘
# 2. 关闭 THP（Transparent Huge Pages）
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 3. 设置 vm.overcommit_memory
echo 'vm.overcommit_memory = 1' >> /etc/sysctl.conf
sysctl -p

# 4. 控制 Redis 内存使用量
maxmemory 4gb  # 不超过物理内存的 50%

六、监控与告警

6.1 INFO 命令监控

# 获取所有信息
redis-cli INFO

# 分类查看
redis-cli INFO server      # 服务器信息
redis-cli INFO clients     # 客户端信息
redis-cli INFO memory      # 内存信息
redis-cli INFO persistence # 持久化信息
redis-cli INFO stats       # 统计信息
redis-cli INFO replication # 复制信息
redis-cli INFO cpu         # CPU 信息
redis-cli INFO cluster     # 集群信息
redis-cli INFO keyspace    # 数据库信息

6.2 关键监控指标

# 内存相关
used_memory              # 已使用内存
used_memory_rss          # 系统分配的内存
mem_fragmentation_ratio  # 内存碎片率
maxmemory                # 最大内存限制
evicted_keys             # 淘汰的 key 数量

# 连接相关
connected_clients        # 当前连接数
blocked_clients          # 阻塞的连接数
rejected_connections     # 拒绝的连接数

# 性能相关
instantaneous_ops_per_sec  # 每秒操作数
hit_rate = keyspace_hits / (keyspace_hits + keyspace_misses)  # 命中率

# 持久化相关
rdb_last_bgsave_status   # 最后一次 RDB 状态
aof_last_rewrite_status  # 最后一次 AOF 重写状态
aof_current_size         # AOF 文件大小

# 复制相关
master_link_status       # 主从连接状态
master_last_io_seconds_ago  # 最后一次通信

6.3 慢查询监控

# 配置慢查询
slowlog-log-slower-than 10000  # 10ms
slowlog-max-len 128            # 保留最近 128 条

# 查看慢查询
SLOWLOG GET 10    # 获取最近 10 条
SLOWLOG LEN       # 慢查询数量
SLOWLOG RESET     # 清空慢查询日志

# 示例输出
# 1) 1) (integer) 14               # 日志 ID
#    2) (integer) 1704067200       # 时间戳
#    3) (integer) 15000            # 耗时（微秒）
#    4) 1) "KEYS"                  # 命令
#       2) "*"

6.4 Prometheus + Grafana 监控

# docker-compose.yml
version: "3"
services:
  redis-exporter:
    image: oliver006/redis_exporter
    ports:
      - "9121:9121"
    environment:
      - REDIS_ADDR=redis://localhost:6379
      - REDIS_PASSWORD=your_password

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"

# prometheus.yml
scrape_configs:
  - job_name: "redis"
    static_configs:
      - targets: ["redis-exporter:9121"]

6.5 告警规则

# alertmanager rules
groups:
  - name: redis
    rules:
      # 内存使用率超过 80%
      - alert: RedisMemoryHigh
        expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis memory usage is high"

      # 连接数过多
      - alert: RedisTooManyConnections
        expr: redis_connected_clients > 500
        for: 5m
        labels:
          severity: warning

      # 命中率过低
      - alert: RedisHitRateLow
        expr: redis_keyspace_hits / (redis_keyspace_hits + redis_keyspace_misses) < 0.9
        for: 10m
        labels:
          severity: warning

      # 主从延迟
      - alert: RedisReplicationLag
        expr: redis_connected_slaves < 1 or redis_master_link_status != 1
        for: 1m
        labels:
          severity: critical

七、故障排查

7.1 常见问题排查

# 1. Redis 无法启动
# 检查日志
tail -f /var/log/redis/redis.log

# 常见原因：
# - 端口被占用
# - 内存不足
# - 配置文件错误

# 2. 连接被拒绝
# 检查防火墙
iptables -L -n | grep 6379

# 检查 bind 配置
grep bind /etc/redis/redis.conf

# 检查 protected-mode
grep protected-mode /etc/redis/redis.conf

# 3. 响应变慢
# 检查慢查询
redis-cli SLOWLOG GET 10

# 检查大 key
redis-cli --bigkeys

# 检查客户端列表
redis-cli CLIENT LIST | grep idle

# 4. 内存问题
# 检查内存使用
redis-cli INFO memory

# 检查淘汰情况
redis-cli INFO stats | grep evicted

# 内存分析
redis-cli MEMORY DOCTOR

7.2 连接问题排查

# 查看当前连接
redis-cli CLIENT LIST

# 关键字段：
# id: 连接 ID
# addr: 客户端地址
# age: 连接时长（秒）
# idle: 空闲时长（秒）
# flags: 客户端标志
# cmd: 最后执行的命令

# 查看连接统计
redis-cli INFO clients

# connected_clients: 当前连接数
# blocked_clients: 阻塞的连接数
# client_recent_max_input_buffer: 最大输入缓冲区
# client_recent_max_output_buffer: 最大输出缓冲区

# 杀死空闲连接
redis-cli CLIENT KILL IDLE 3600  # 杀死空闲超过 1 小时的连接

# 设置超时
timeout 300  # 300 秒无活动则断开

7.3 内存问题排查

# 内存使用详情
redis-cli MEMORY STATS

# 特定 key 的内存占用
redis-cli MEMORY USAGE key [SAMPLES count]

# 内存诊断
redis-cli MEMORY DOCTOR

# 大 key 扫描
redis-cli --bigkeys

# 内存采样
redis-cli --memkeys

# 分析 RDB 文件
rdb --command memory dump.rdb --bytes 10240 > memory-report.csv

7.4 性能问题排查

# 实时监控命令
redis-cli MONITOR

# 查看命令统计
redis-cli INFO commandstats

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

# 内存延迟测试
redis-cli --intrinsic-latency 5

# 检查持久化影响
redis-cli INFO persistence
# - rdb_bgsave_in_progress: 是否正在 BGSAVE
# - aof_rewrite_in_progress: 是否正在 AOF 重写
# - latest_fork_usec: 最近一次 fork 耗时

八、生产环境运维

8.1 部署建议

# 1. 系统配置
# /etc/sysctl.conf
vm.overcommit_memory = 1
vm.swappiness = 1
net.core.somaxconn = 1024
net.ipv4.tcp_max_syn_backlog = 1024

# 2. 关闭 THP
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag

# 3. 文件描述符限制
# /etc/security/limits.conf
* soft nofile 65535
* hard nofile 65535

# 4. 使用非 root 用户运行
useradd -r -s /sbin/nologin redis
chown -R redis:redis /data/redis

8.2 备份策略

#!/bin/bash
# backup.sh - Redis 备份脚本

BACKUP_DIR="/backup/redis"
DATE=$(date +%Y%m%d_%H%M%S)
REDIS_DATA_DIR="/data/redis"

# 创建备份目录
mkdir -p $BACKUP_DIR

# 触发 BGSAVE
redis-cli -a password BGSAVE

# 等待 BGSAVE 完成
while [ $(redis-cli -a password LASTSAVE) == $(cat /tmp/redis_lastsave 2>/dev/null) ]; do
    sleep 1
done
redis-cli -a password LASTSAVE > /tmp/redis_lastsave

# 复制 RDB 文件
cp $REDIS_DATA_DIR/dump.rdb $BACKUP_DIR/dump_$DATE.rdb

# 压缩
gzip $BACKUP_DIR/dump_$DATE.rdb

# 上传到远程存储（可选）
# aws s3 cp $BACKUP_DIR/dump_$DATE.rdb.gz s3://your-bucket/redis-backup/

# 清理旧备份（保留 7 天）
find $BACKUP_DIR -name "*.gz" -mtime +7 -delete

echo "Backup completed: dump_$DATE.rdb.gz"

8.3 安全配置

# 1. 绑定内网 IP
bind 192.168.1.10

# 2. 设置密码
requirepass your_strong_password_here

# 3. 禁用危险命令
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_secret_key"
rename-command KEYS ""
rename-command DEBUG ""
rename-command SHUTDOWN "SHUTDOWN_secret_key"

# 4. 开启保护模式
protected-mode yes

# 5. 禁止外网访问（防火墙）
# iptables -A INPUT -p tcp --dport 6379 -s 192.168.1.0/24 -j ACCEPT
# iptables -A INPUT -p tcp --dport 6379 -j DROP

# 6. 使用 TLS（Redis 6.0+）
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

8.4 日常运维命令

# 查看服务状态
redis-cli PING

# 查看配置
redis-cli CONFIG GET *
redis-cli CONFIG GET maxmemory

# 动态修改配置
redis-cli CONFIG SET maxmemory 4gb
redis-cli CONFIG SET maxmemory-policy allkeys-lru

# 持久化配置到文件
redis-cli CONFIG REWRITE

# 查看客户端连接
redis-cli CLIENT LIST | wc -l

# 清理空闲连接
redis-cli CLIENT KILL IDLE 3600

# 查看内存使用
redis-cli INFO memory | head -20

# 查看 key 数量
redis-cli DBSIZE

# 慢查询分析
redis-cli SLOWLOG GET 10

# 手动触发 RDB
redis-cli BGSAVE

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

九、性能调优清单

9.1 配置优化清单

配置项	推荐值	说明
maxmemory	物理内存的 50-70%	预留给 fork 和系统
maxmemory-policy	allkeys-lru	根据场景选择
maxclients	10000	根据业务调整
timeout	300	空闲连接超时
tcp-keepalive	300	TCP 保活
tcp-backlog	511	TCP 队列
appendonly	yes	开启 AOF
appendfsync	everysec	每秒同步
aof-use-rdb-preamble	yes	混合持久化
slowlog-log-slower-than	10000	10ms
slowlog-max-len	128	保留条数

9.2 开发规范清单

规范	说明
Key 命名	业务:类型:ID，不超过 44 字节
Value 大小	String 不超过 10KB
集合元素	Hash/List/Set/ZSet 元素不超过 5000
过期时间	所有缓存必须设置过期时间
批量操作	使用 Pipeline 或 Lua 脚本
禁用命令	KEYS、FLUSHALL、FLUSHDB
连接池	使用连接池，配置合理的参数

9.3 监控告警清单

指标	告警阈值	说明
内存使用率	> 80%	及时扩容或清理
连接数	> 80% maxclients	检查连接泄漏
命中率	< 90%	优化缓存策略
淘汰 key 数	> 0	内存不足
慢查询数	> 100/min	优化命令
主从延迟	> 10s	检查网络和负载
fork 耗时	> 500ms	优化持久化配置

十、总结

性能优化要点

命令优化：避免慢命令，使用 Pipeline 和 Lua
内存优化：控制 Key/Value 大小，使用压缩列表
网络优化：使用连接池，合理配置连接参数
持久化优化：根据场景选择 RDB/AOF，使用混合持久化

运维要点

监控全面：内存、连接、性能、持久化
告警及时：设置合理的告警阈值
备份可靠：定期备份，异地存储
安全加固：密码、防火墙、禁用危险命令

故障处理

连接问题：检查网络、连接数、超时配置
内存问题：检查大 key、淘汰策略、碎片
性能问题：检查慢查询、持久化、CPU 使用
数据问题：检查持久化状态、主从同步