警报
周三下午收到一条 Redis 内存告警:集群内存使用率从 45% 涨到了 82%。
我们的 Redis 集群是给十几个服务共用的,平时内存 2.3G 左右,波动不大。那天下午涨到了 5.1G。涨了将近 3 个 G,而且还在涨。
第一反应是有人写了个没设 TTL 的大 key。这种事在共用的 Redis 上太常见了。
定位:一堆看不懂的 key
先看总量:
bash
redis-cli -h xxx -p 6379 --bigkeys
--bigkeys 只告诉我们最大的那个 value 有多大,但我们要找的是大量小的、不断增长的 key。
换用 --memkeys:
bash
redis-cli -h xxx -p 6379 --memkeys
也没有明显异常。
那就只能数。按前缀统计:
bash
redis-cli -h xxx -p 6379 --scan --count 1000 | head -100000 | awk -F: '{print $1}' | sort | uniq -c | sort -rn | head -20
跑出来的结果里有一行很扎眼:
412873 \xac\xed\x00\x05t\x00\x0forder:cache
四十多万个 key,前缀是一堆乱码。
再实际捞一个出来看:
bash
redis-cli -h xxx -p 6379 --scan --pattern '*order:cache*' --count 5
arduino
"\xac\xed\x00\x05t\x00\x12order:cache:202610..."
"\xac\xed\x00\x05t\x00\x12order:cache:202610..."
看到 \xac\xed\x00\x05 这个前缀,我心里就有数了。
这是 Java 原生序列化的魔术头。
0xACED 是 Java ObjectOutputStream 的流魔数(STREAM_MAGIC),0x0005 是版本号。后面那个 t 是 TC_STRING 标记,再往后是字符串长度和内容。
根因:RedisTemplate vs StringRedisTemplate
Spring Data Redis 提供了两个模板:
StringRedisTemplate:key 和 value 都用StringRedisSerializer,存进去什么样,Redis 里就是什么样。RedisTemplate:默认用JdkSerializationRedisSerializer,key 和 value 都会被 Java 序列化成二进制。
我们有个服务,代码里写的是:
java
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void cacheOrder(String orderNo, OrderVO order) {
redisTemplate.opsForValue().set("order:cache:" + orderNo, order, 30, TimeUnit.MINUTES);
}
作者的想法大概是"我要存对象,所以用 RedisTemplate"。这没错,但他没有配置 key 的序列化器。
RedisTemplate 默认的 key 序列化器是 JdkSerializationRedisSerializer,所以 key "order:cache:xxx" 被序列化成了 \xac\xed\x00\x05t\x00\x12order:cache:xxx。
这一串二进制在 Redis 里是 26 个字节,而原字符串只有 18 字节。四十多万个 key,光 key 本身的内存开销就白白多出来了。
更要命的是------这个 key 你没法用普通的方式删。
bash
redis-cli DEL "order:cache:20261012001"
删不掉。因为 Redis 里真实的 key 是那串二进制。你在客户端输的字符串,跟它不匹配。
这就是那 3 个 G 的来源。而且因为这个 key 是被 Java 序列化的,每次业务代码去找它,都是拿 "order:cache:xxx" 去匹配那个二进制 key(通过同样的序列化器),所以业务上竟然一切正常。程序跑得好好的,只有内存悄悄涨。
顺便发现:同一个 key 存了两份
清理的时候我又发现一个更隐蔽的问题。
我用 SCAN 找 order:cache 的时候,发现有两批 key:
less
\xac\xed\x00\x05t\x00\x12order:cache:20261012001 <- 服务A写的(JdkSerialization)
order:cache:20261012001 <- 服务B写的(String)
同一个业务 key,两个服务各存了一份。
服务 A 用了 RedisTemplate(默认序列化),服务 B 用了 StringRedisTemplate。两边读的时候都读自己的那份,所以各自都正常。但数据是双份的,内存也是双份的。
而且如果哪天 A 读到了 B 写的(比如运维手动用 redis-cli 修了个值),就会直接抛 SerializationException,因为它们解读字节的方式不同。
修复
修复分三步。
第一步:统一序列化配置。
我们定了个规范:
- key 一律用
StringRedisSerializer(这是铁律,key 必须是可读的字符串) - value:简单字符串用
StringRedisSerializer,对象用GenericJackson2JsonRedisSerializer
统一配一个模板:
java
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
StringRedisSerializer keySerializer = new StringRedisSerializer();
GenericJackson2JsonRedisSerializer valueSerializer =
new GenericJackson2JsonRedisSerializer();
template.setKeySerializer(keySerializer);
template.setHashKeySerializer(keySerializer);
template.setValueSerializer(valueSerializer);
template.setHashValueSerializer(valueSerializer);
template.afterPropertiesSet();
return template;
}
}
注意 GenericJackson2JsonRedisSerializer 会在 JSON 里额外写入 @class 字段来记录类型,这样反序列化时能还原成原来的类。代价是存储稍微大一点,但换来的是可读性和可维护性。
如果你不想要 @class,可以用 Jackson2JsonRedisSerializer<Object> 配合自定义的 ObjectMapper,但那样就只能反序列化成 Map 了。取舍看场景。
第二步:清历史脏数据。
这个要小心,不能用 KEYS,几十万个 key 会把 Redis 阻塞住。
用 SCAN:
bash
#!/bin/bash
# 分批删除 Java 序列化格式的脏 key
redis-cli -h $HOST -p $PORT --scan --pattern '*order:cache*' --count 500 | \
while read -r key; do
# 只删带 Java 序列化魔数的(用前缀匹配不现实,这里按长度和不可见字符判断)
echo "DEL '$key'"
done | redis-cli -h $HOST -p $PORT --pipe
实际执行的时候我是先用 Lua 脚本试删了一小批,确认没误伤业务 key(因为业务已经不用这个格式了),再全量删。
这里有个经验:删 Redis 数据之前,一定要先确认"这个 key 现在还有人读吗"。 我的办法是先删 100 个,观察半小时业务日志有没有异常,再删 1000 个,再观察。慢慢来。
第三步:加监控。
事后我在 Redis 层面加了个告警:如果一分钟内出现大量以 \xac\xed 开头的 key,直接告警。写了个小脚本跑在巡检任务里:
bash
redis-cli --scan --pattern '*' --count 1000 | \
grep -c $'\xac\xed' || true
这个脚本一直留着,后来又抓到过一次------另一个服务的新同学又踩了同一个坑。
第二个坑:Redisson 的 INCRBY
序列化这件事解决之后,我在同一个项目里又踩了一个相关的坑。
我们有个接口限流计数器,用的是 Redisson:
java
// 第一版:用 RBucket 存数字,然后 getAndSet
RBucket<Long> bucket = redissonClient.getBucket("limit:api:" + api);
Long current = bucket.get();
if (current == null) {
bucket.set(1L, 1, TimeUnit.MINUTES);
return true;
}
if (current >= maxQps) {
return false;
}
bucket.set(current + 1, 1, TimeUnit.MINUTES);
这段代码有并发问题------读和写不是原子的。两个请求同时读到 current=5,都写成 6,就少计了一次。
改成原子操作:
java
RAtomicLong counter = redissonClient.getAtomicLong("limit:api:" + api);
long current = counter.incrementAndGet();
看起来很合理,但上线之后报错:
sql
org.redisson.client.RedisException:
ERR value is not an integer or out of range
查了一下原因:RBucket 和 RAtomicLong 用的编码器不一样。
RAtomicLong内部用LongCodec,存的是纯数字字符串(比如"6"),能被 Redis 的INCR直接处理。RBucket用默认编码器(我们配的是JsonJacksonCodec),存的是带元信息的序列化字节。
所以我先用 RBucket 存了 1,再用 RAtomicLong 去 incrementAndGet,Redis 拿到的那串字节不是数字,INCR 直接报错。反过来也一样。
教训:同一个 key,从始至终只能用同一种数据类型和编码器去操作。 别一会儿 RBucket 一会儿 RAtomicLong,它们眼里的"值"根本不是同一回事。
修法有两种,我选了第一种:
java
// 方案一:全程用 RAtomicLong,并且显式指定 LongCodec(默认就是,这里只是写出来强调)
RAtomicLong counter = redissonClient.getAtomicLong(key);
// 方案二:如果一定要用 RBucket,就显式指定编码器
RBucket<String> bucket = redissonClient.getBucket(key, StringCodec.INSTANCE);
顺带说一个更隐蔽的情况:如果某个 key 被 RedisTemplate 写过(比如被一个临时脚本写了个 "0"),Redisson 的 RAtomicLong 也是能用的 ,因为 "0" 本身就是合法整数。但如果 RedisTemplate 配的是 JSON 序列化,写进去的是 "\"0\""(带引号),那就又不匹配了。
这种跨客户端、跨序列化方案的混用,是 Redis 使用中最容易出事故的地方。
Redis 消息队列:我踩过的另一个小坑
顺便提一下,我们后来还用 Redis Stream 做过轻量级的消息队列(因为不想为了一个小功能引入 MQ)。
Stream 的 XADD / XREADGROUP / XACK 用起来挺顺手,但有两点要注意:
1. 消息不会自动删除。 XADD 加进去的消息会一直保留,要配 MAXLEN 截断:
java
// Redisson 里
RStream<String, String> stream = redissonClient.getStream("order:stream");
stream.add(StreamAddArgs.entry("id", orderId), StreamMessageId.AUTO_GENERATED, 1000, true);
// 上面这个 1000 就是 MAXLEN
或者用 Redis 的 XADD key MAXLEN ~ 1000 * field value,~ 表示近似截断,性能更好。
2. Pending 列表会累积。 如果消费方一直不 XACK,pending 列表会越来越大。得有一个定时任务去 XPENDING 检查并处理死信。
我们用 Redisson 的 RStream 时,XACK 是通过 stream.ack(group, msgId) 做的。注意 group 要先创建:
java
stream.createGroup(StreamMessageId.NEWEST, "myGroup");
这个 StreamMessageId.NEWEST 表示从最新消息开始消费。如果你想要从头消费,用 StreamMessageId.ALL。我第一次用的时候选了 NEWEST,结果测试时发的消息一条都收不到,白白查了半天。
最后
Redis 的使用坑,我总结下来就一句话:
别让同一个 key,在不同的地方有不同的"解释方式"。
序列化方式、编码器、数据类型------任何一个维度上不统一,都会产生"程序跑得好好的但内存/数据坏了"这种最难查的问题。
具体到实践:
- key 一律用
StringRedisSerializer,别让 key 变成二进制。key 是给人看的。 - 一个项目里只保留一套 Redis 配置 ,别让不同的模块各自
new RedisTemplate()。 - 同一个 key 只用一种客户端、一种编码器操作。 用 Redisson 就全用 Redisson。
- 加一个巡检脚本,盯着有没有新的二进制 key 出现。
第 4 条最土,但最有用。我加了这个巡检之后,又抓到了两次同类问题------如果不加,它们大概会像那 3 个 G 一样,悄悄涨到把集群撑爆。