Redis内存管理与8种淘汰策略详解

1. Redis内存管理的基本原理

Redis作为内存数据库，其性能优势很大程度上依赖于将数据存储在内存中。然而内存资源是有限的，当Redis实例使用的内存超过物理内存容量时，操作系统会开始使用交换空间（swap），这将导致性能急剧下降。因此Redis需要一套完善的内存管理机制来防止这种情况发生。

Redis的内存管理主要通过两个参数控制：

• maxmemory：设置Redis可以使用的最大内存量
• maxmemory-policy：设置内存达到上限时的淘汰策略

当Redis占用的内存达到maxmemory限制时，会根据配置的淘汰策略决定如何释放内存。如果没有设置淘汰策略或者无法根据策略释放内存，Redis会对可能导致内存增加的写命令返回错误（如SET、LPUSH等），但读命令仍然可以正常执行。

重要提示：生产环境中务必设置maxmemory参数，建议设置为物理内存的70-80%，为系统和其他进程预留足够内存空间。

2. Redis的8种内存淘汰策略详解

2.1 noeviction策略

这是Redis的默认策略，当内存达到限制时，所有会引起内存增加的写命令都会返回错误，读命令可以正常执行。这种策略适合数据绝对不能丢失的场景，但需要应用层自己处理写操作失败的情况。

配置方式：

code复制maxmemory-policy noeviction

适用场景：

• 数据极其重要，宁可拒绝服务也不能丢失
• 应用层有完善的降级处理机制
• 内存使用量相对稳定，很少达到上限

2.2 allkeys-lru策略

该策略会尝试移除最近最少使用的键（Least Recently Used），无论这个键是否设置了过期时间。这是最常用的策略之一，适合大多数场景。

实现原理：

1. Redis维护一个全局LRU时钟
2. 每次访问键时会更新其最近使用时间
3. 当需要淘汰时，随机采样若干键，淘汰其中最久未被访问的

配置示例：

code复制maxmemory-policy allkeys-lru
maxmemory-samples 5  # 每次淘汰时采样的键数量

调优建议：

• 增大maxmemory-samples可以提高淘汰的准确性，但会增加CPU开销
• 对于特别大的实例（10GB以上），建议设置为10
• 可以通过OBJECT IDLETIME key命令查看键的空闲时间

2.3 volatile-lru策略

只从设置了过期时间的键中淘汰最近最少使用的键。相比allkeys-lru，这种策略可以保证永久键不会被淘汰。

配置方式：

code复制maxmemory-policy volatile-lru

适用场景：

• 部分数据可以丢失，部分绝对不能丢失
• 明确知道哪些数据可以设置过期时间
• 需要更精确控制哪些数据可以被淘汰

2.4 allkeys-random策略

随机移除键来释放内存，无论是否设置了过期时间。这种策略性能最好但最不精确。

配置示例：

code复制maxmemory-policy allkeys-random

使用场景：

• 所有数据重要性相同
• 访问模式没有明显热点
• 追求极致的性能，可以接受一定的误淘汰

2.5 volatile-random策略

只从设置了过期时间的键中随机移除。与volatile-lru类似，但采用随机选择而非LRU算法。

配置方式：

code复制maxmemory-policy volatile-random

适用情况：

• 与volatile-lru类似，但对性能要求更高
• 过期键的访问模式没有明显规律

2.6 volatile-ttl策略

从设置了过期时间的键中，优先移除剩余生存时间(TTL)较短的键。这种策略基于"即将过期的键可能不再需要"的假设。

配置示例：

code复制maxmemory-policy volatile-ttl

适用场景：

• 过期时间设置合理，能反映数据重要性
• 短期数据和长期数据混合存储
• 希望尽可能利用数据的完整生命周期

2.7 volatile-lfu策略（Redis 4.0+）

从设置了过期时间的键中，移除最不经常使用(Least Frequently Used)的键。LFU算法会统计键的访问频率。

配置方式：

code复制maxmemory-policy volatile-lfu
lfu-log-factor 10
lfu-decay-time 1

参数说明：

• lfu-log-factor：控制计数器增长速度
• lfu-decay-time：计数器衰减时间（分钟）

2.8 allkeys-lfu策略（Redis 4.0+）

从所有键中移除最不经常使用的键，无论是否设置了过期时间。这是LFU算法的全局版本。

配置示例：

code复制maxmemory-policy allkeys-lfu

3. 策略选择与性能优化

3.1 如何选择合适的淘汰策略

选择淘汰策略需要考虑以下因素：

1. 数据重要性：

   • 绝对不能丢失：noeviction
   • 部分可以丢失：根据访问模式选择LRU/LFU/Random

2. 访问模式：

   • 有明显热点：LRU/LFU
   • 均匀访问：Random
   • 周期性访问：TTL

3. 性能需求：

   • 高吞吐：Random
   • 高命中率：LRU/LFU

4. Redis版本：

   • 4.0以下：无LFU策略
   • 6.0+：有更多优化

3.2 内存淘汰的性能影响

不同策略的CPU开销排序（从高到低）：

1. LFU（需要维护频率计数器）
2. LRU（需要维护访问时间）
3. TTL（需要检查过期时间）
4. Random（几乎无额外开销）

优化建议：

• 对于大内存实例，适当增加maxmemory-samples
• 监控evicted_keys指标，如果持续很高说明淘汰压力大
• 考虑使用Redis集群分散内存压力

3.3 实际案例对比

我们在生产环境测试了三种策略的效果（8GB内存，QPS 10k）：

从测试可以看出：

• LRU策略命中率最高但延迟略高
• Random策略性能最好但命中率较低
• TTL策略在合理设置过期时间时表现均衡

4. 高级应用与实战技巧

4.1 混合策略的使用

在实际生产中，可以采用分层策略：

1. 对基础数据使用volatile-ttl
2. 对缓存数据使用allkeys-lru
3. 对不重要数据使用allkeys-random

实现方法是通过多个Redis实例，不同业务数据存储在不同实例并配置不同策略。

4.2 内存淘汰的监控与告警

关键监控指标：

• used_memory：已用内存
• mem_fragmentation_ratio：内存碎片率
• evicted_keys：被淘汰的键数量
• keyspace_misses：键查找失败次数

建议告警阈值：

• 内存使用 > 90% maxmemory
• 碎片率 > 1.5
• 每分钟淘汰键数 > 100

4.3 特殊场景处理

大键淘汰问题：
当有大键（如几百MB的hash）需要淘汰时，会导致Redis阻塞。解决方案：

• 避免存储过大的键
• 使用LAZYFREE相关配置（Redis 4.0+）

code复制lazyfree-lazy-eviction yes

内存碎片问题：
长时间运行可能导致内存碎片。解决方法：

• 启用内存碎片整理（Redis 4.0+）

code复制activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10

4.4 Redis 6.0+的改进

Redis 6.0对内存淘汰做了多项优化：

1. 更高效的LRU算法实现
2. 支持淘汰时的后台线程处理
3. 更精确的内存统计信息
4. 支持客户端缓存淘汰通知

配置示例：

code复制# 启用后台线程处理淘汰
lazyfree-lazy-eviction yes
# 客户端缓存淘汰通知
notify-keyspace-events Eg

5. 常见问题与解决方案

5.1 为什么设置了淘汰策略但内存还在增长？

可能原因：

1. 淘汰速度跟不上写入速度
2. 有大键无法被淘汰
3. 内存碎片过多

解决方案：

1. 检查evicted_keys指标是否在增长
2. 使用redis-cli --bigkeys查找大键
3. 重启实例或启用内存碎片整理

5.2 如何测试淘汰策略的效果？

测试步骤：

1. 使用redis-benchmark模拟负载
2. 使用INFO stats查看淘汰情况
3. 使用redis-cli monitor观察淘汰过程

示例测试命令：

code复制# 填充测试数据
redis-cli --eval populate.lua , 1000000

# 模拟访问
redis-benchmark -t get,set -n 1000000 -r 1000000

5.3 生产环境配置建议

典型生产配置：

code复制maxmemory 16gb
maxmemory-policy allkeys-lru
maxmemory-samples 10
lazyfree-lazy-eviction yes
activedefrag yes

调优过程：

1. 从保守配置开始
2. 监控关键指标
3. 逐步调整参数
4. 进行压力测试
5. 观察线上表现

5.4 Redis与其他缓存系统的策略对比

选择建议：

• 需要丰富策略：Redis
• 纯缓存场景：Memcached
• Java应用：Ehcache/Caffeine

6. 从源码看Redis内存淘汰

6.1 核心数据结构

Redis在redis.h中定义了淘汰策略相关的数据结构：

c复制struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time or LFU data */
    int refcount;
    void *ptr;
};

对于LRU策略，lru字段存储最后访问时间戳；对于LFU策略，它存储访问频率和衰减时间。

6.2 淘汰策略实现

淘汰过程在evict.c中实现，主要函数：

• freeMemoryIfNeeded()：检查并执行淘汰
• evictionPoolPopulate()：填充候选键池
• performEvictions()：执行实际淘汰

LRU实现关键代码：

c复制// 更新键的LRU时钟
void updateLRU(robj *o) {
    if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
        o->lru = LRU_CLOCK();
    }
}

// 获取LRU时钟
unsigned int LRU_CLOCK(void) {
    return (mstime()/LRU_CLOCK_RESOLUTION) & LRU_CLOCK_MAX;
}

6.3 LFU算法实现

LFU的实现更为复杂：

c复制// 更新LFU计数器
void updateLFU(robj *o) {
    unsigned long counter = LFUDecrAndReturn(o);
    counter = LFULogIncr(counter);
    o->lru = (LFUGetTimeInMinutes()<<8) | counter;
}

// 对数递增计数器
uint8_t LFULogIncr(uint8_t counter) {
    if (counter == 255) return 255;
    double r = (double)rand()/RAND_MAX;
    double baseval = counter - LFU_INIT_VAL;
    if (baseval < 0) baseval = 0;
    double p = 1.0/(baseval*server.lfu_log_factor+1);
    if (r < p) counter++;
    return counter;
}

6.4 性能优化点

Redis在淘汰策略实现上做了多项优化：

1. 使用采样的方式避免全量扫描
2. 维护淘汰候选池减少重复计算
3. 惰性删除减少阻塞时间
4. 后台线程处理（6.0+）

这些优化使得即使在大内存场景下，淘汰操作对性能的影响也很小。