Redis List 做轻量消息队列:从底层原理到避坑实践
提到 Redis,很多人第一反应就是缓存,get、set、过期时间,仅此而已。但我做后端这些年,真正让我觉得 Redis 耐用的地方,其实是它那几张数据类型。今天把 List 单独拿出来讲清楚——不是教你背命令,而是把它当成一个“轻量消息队列”来搞明白。这篇文章会从 List 的底层存储聊起,讲它的性能边界、常用命令,再深入到用 List 搭消息队列时一定会踩的重复消费、消息丢失这些坑,最后聊一聊和 Kafka、RabbitMQ、RocketMQ 这些专业队列之间到底怎么选。适合刚学 Redis 的同学,也适合用了好几年 Redis 但从没认真抠过 List 细节的老手。
1. 先搞清楚:List 在 Redis 里到底是怎么存的
1.1 从双向链表到 quicklist:内存与性能的多次妥协
很多教程会告诉你,Redis List 的底层是双向链表。这句话放在 Redis 3.2 之前没毛病,但今天的实现早就不是这么简单了。
早期版本里的 List 确实就是一个 linkedlist,每个节点都存着 prev、next 指针和数据指针。优点很明显:头尾插入和删除都是 O(1),删除任意节点也不需要搬数据。但缺点同样致命——每个节点都要附带大量指针,内存开销大得吓人;节点之间内存不连续,Redis 又是单线程模型,遍历的时候 CPU 缓存命中率也很差。存 10 万个只有 3 字节的整数,光节点本身的指针开销就可能超过数据本身十几倍。
后来 Redis 引入了 ziplist,把一整串元素紧凑地塞在一块连续内存里。这种方案省内存省得很夸张,但引入了另一个有名的坑:连锁更新。ziplist 里每个节点的 prevlen 字段记录了前一个节点的长度,如果前一个节点修改后长度发生了跨档位变化,后一个节点的 prevlen 就需要扩容,然后继续引发后一个、后后一个……极端情况下一次插入要带动后面所有节点的内存搬移。这个坑在元素多的列表上会直接吃满 CPU,表现为 Redis 卡顿。
Redis 3.2 之后官方给出的答案是 quicklist。quicklist 本质上还是一个双向链表,但它的每个节点里装的不是一个元素,而是一个小型的压缩列表或 listpack。用大白话说,就是把之前成百上千个“小车厢”改装成了“大集装箱”,每个集装箱里塞一批货,集装箱之间再用链式结构连起来。这样既保留了链表头尾操作快的特性,又把指针数量砍掉了一个数量级,内存碎片问题也大幅缓解。
Redis 7.0 又做了最后一次大调整:用 listpack 全面替换了 ziplist。listpack 改变了 entry 的记录方式,不保存前一个节点的长度,自然也就没有了连锁更新问题。换句话说,今天你看到一个长度很短的 List,底层大概率就是单个 listpack;等到元素变多或单个元素很大会自动升级成 quicklist。
1.2 编码切换与两个性能边界
Redis 的 List 有两种编码类型:OBJ_ENCODING_LISTPACK 和 OBJ_ENCODING_QUICKLIST。什么时候用哪种?主要看 list-max-listpack-size 这个配置项。它控制 quicklist 里每个节点最多能容纳多少元素或多少字节的数据,一旦单个 listpack 超过这个阈值,Redis 就会把它拆成多个节点,整个对象升级成 quicklist。
另一个配置项 list-compress-depth 也很关键。它表示 quicklist 两端各有多少个节点不做压缩,其余中间节点用 LZF 算法压缩。默认是 0,也就是不压缩,全部节点裸奔。如果业务里 List 很长,但读取永远集中在头部和尾部(消息队列的典型模式),把 list-compress-depth 设成 1 或 2 能省不少内存。
聊性能和编码,必须划两条边界线。第一条:List 的“头尾操作是 O(1)”,别理解成整个 List 都适合任何操作。LINDEX、中间位置的插入删除都是 O(N),数据量上去之后一次中间操作就可能触发长时间 CPU 占用,直接影响本实例上的其他命令。第二条:大 List 千万别一把梭全量取出。LRANGE key 0 -1 对几十万元素的 List 来说,会瞬间把数据塞进网络缓冲区,轻则响应超时,重则直接打爆 Redis 的乐观锁内存限制。我自己见过一次线上事故,就是有人对长 List 做了全量 range,结果 Redis 主线程被卡了几秒,整个服务链路的读写全部抖动。
经验上,你可以在 redis-cli 里用 DEBUG OBJECT key 查看某个键当前的编码类型,也可以定期用 redis-cli --bigkeys 扫一下实例里的大 key,凡是能看到超大 List 的,其实都是一个等待爆发的坑。
2. 命令别靠背:把 List 玩明白的关键操作
2.1 Push/Pop:左右分不清,消费就乱套
List 在语义上是一个有序的字符串序列,左右两端都能操作,所以看命令千万别只看“插入”“取出”,一定要盯住左右方向。下面这张表我按实际使用频率排了序,建议照着敲一遍。
| 命令 | 作用 | 复杂度 |
|---|---|---|
| LPUSH key element [element...] | 往列表左侧(头部)插入一个或多个元素 | O(1) 每个 |
| RPUSH key element [element...] | 往列表右侧(尾部)插入一个或多个元素 | O(1) 每个 |
| LPOP key | 从左侧取出并删除一个元素 | O(1) |
| RPOP key | 从右侧取出并删除一个元素 | O(1) |
| BLPOP key timeout | 阻塞式从左侧取出,超时返回 nil | O(1) |
| BRPOP key timeout | 阻塞式从右侧取出,超时返回 nil | O(1) |
| LRANGE key start stop | 取出索引区间的元素 | O(N) |
| LINDEX key index | 按下标取元素 | O(N) |
| LLEN key | 返回列表长度 | O(1) |
| LREM key count element | 删除匹配的元素,count>0 从头删,count<0 从尾删,count=0 全删 | O(N) |
| LTRIM key start stop | 只保留区间内的元素,其余删除 | O(N) |
| RPOPLPUSH source dest | 从源右端弹出并插入目标左端 | O(1) |
| LMOVE source dest LEFT/RIGHT LEFT/RIGHT | 从源指定端弹出并插入目标指定端 | O(1) |
最经典的消费模式是“LPUSH 入队,BRPOP 出队”。生产者把任务压到左边,消费者从右边阻塞取,这样入队顺序和出队顺序一致,天然形成 FIFO 队列:
这里每次消费之前要搞清楚:如果你用了 RPUSH 入队又用 RPOP 出队,那也是一个队列,但左右顺序调了个头。真正让人混乱的是有人左手 LPUSH、右手 RPOP,以为自己在用队列,结果取出来的顺序完全是自己预期的反方向。不是 bug,是左右没分清楚。
2.2 阻塞命令:队列不空转的底层机制
BRPOP 和 BLPOP 是 List 能做消息队列的核心底气。它们允许消费者在没有数据时进入阻塞状态,而不是空转轮询。第二参数 timeout 单位是秒,传 0 代表永久阻塞。这点很重要,很多人传了一个没意义的 30,30 秒后返回 nil,消费者代码没处理好就开始疯狂重试,白瞎了阻塞语义。
阻塞唤醒的机制也值得说透。多个客户端同时阻塞在同一个 key 上时,Redis 不是随机挑一个,而是按阻塞的先后顺序来,谁先来谁先取到数据。这保证了多个消费者场景下不会出现“饿死”某个消费者。
还有一个容易被忽略的细节:阻塞读如果等到了数据,Redis 会先把元素从列表里移除,再返回给客户端。也就是说“取出”这一步是原子的,但“取出后处理”这一步不在 Redis 的保护范围内。客户端在处理消息的过程中崩了,消息一样会丢。这就是后面要重点讲的可靠性问题。
2.3 LTRIM、LREM 与 LMOVE:List 的精细操作
除了入队出队,List 还有几个很实用的“精细操作”。
LTRIM 是天然的时间线限制器。比如做用户动态流,每次新增动态后顺手 LTRIM feed:user:1001 0 99,列表就永远只保留最近 100 条。做站内通知、操作日志、最近浏览记录,这种“只保留最近 N 条”的需求,用 LTRIM 几乎零成本。
LREM 的 count 参数最容易踩坑。LREM key 0 value 会删除所有匹配的元素,如果你只是想删一个,不小心就删成清空主题。我见过有人用 LREM key 0 "task:3" 打算删一条待处理任务,结果把历史积压的十条相同任务全删了。正确的做法是带着业务语义明确传 1 或者 -1。
LMOVE 是我最看重的命令之一。它可以从源列表指定端弹出一个元素,再插入到目标列表指定端,而且整个过程原子完成。Redis 6.2 起提供的这个命令,替代了老牌的 RPOPLPUSH。它最大的价值在于,能实现“消息队列 + 处理中队列”的可靠消费模型,后面专门展开讲。
3. 用 List 手搓消息队列:流程与可靠性补强
3.1 最简单的 LPUSH + BRPOP 方案
如果你只是内部系统要传任务,比如发个通知、刷新个缓存、跑个异步导出,用 LPUSH + BRPOP 这种组合真的很香。不需要引入额外的中间件,Redis 本来就部署了,一条命令的事。
生产端逻辑就是入队:
消费端逻辑框架可以这么写:
这套方案的核心优点有两个:一是消费者不会空转,CPU 占用几乎为零,延迟也极低;二是命令本身原子,多个消费者并发 BRPOP 不会拿到同一条消息。注意,这个“不会拿到同一条”仅限于 Redis 取数这一步,后面结合业务讨论时,依然可能有重复。
3.2 可靠性补强:RPOPLPUSH / LMOVE 与备份列表
真正想在生产环境用 List 做队列,就得解决“消费者把消息取走后崩溃”的问题。最朴素的思路是:别直接把消息弹走,而是弹到另一个“处理中”列表里。消费者处理完,再从处理中列表删掉;消费者没处理完就挂了,处理中列表会留下一堆待恢复的消息。这正是 LMOVE 的场景。
伪代码框架就变成:
这套模拟 ACK 的模型,解决了“消息被取走但没处理完”这个核心痛点。但要注意,lrem 是按值删除,如果同一条消息在 processing 里有多个副本,你要结合业务 ID 精确定位;更严谨的做法是每个消息带上唯一 ID,比如 "task:3:order:123"。另外,processing 列表也需要一个兜底恢复任务,定期扫描里面超时的消息,再塞回主队列。这已经是把 List 当 MQ 用了。
如果你在用 Lua 做更复杂的原子化操作,可以参考这段脚本的思路,把“弹出 + 入备份”合并成一个原子操作:
3.3 延迟消息队列的轻量实现
延迟消息也是老生常谈的需求。最经典的轻量实现不依赖 List,而是先配合 ZSet 存延迟消息,score 存执行时间戳,再由一个扫描任务把到期消息搬到 List 队列里。
做法很简单:生产消息时 ZADD delay:queue <exec_time> <message_id>。消费者定时执行下面这段逻辑,把到期消息搬运到 List:
这套方案够轻、够稳,但只适合“分钟级延迟也能接受”的场景。因为扫描周期决定了延迟精度,而且脚本不是常驻进程,需要外部调度。真要精确到秒级大量延迟消息,还是 RocketMQ 的定时消息更省心。
4. 重复消费、消息丢失:真实项目里的坑与应对
4.1 重复消费的三条必经之路
先给结论:用 Redis List 做队列,重复消费不是“可能发生”,而是“一定发生过”。至少有三条必经之路。
第一条是客户端超时重试。消费者设置了比如 2 秒超时,但业务处理实际需要 5 秒,客户端等不到结果就重新发起 BRPOP,于是同一条消息被第二个消费者线程取走。第二个是消费线程池的并发问题。很多人会让多个 worker 同时各自 BRPOP,Redis 层面不会重复给同一条消息,但如果 worker 的业务逻辑里有重试,或者入库后进程重启,消息就可能处理两遍。第三条最要命:业务本身不幂等。比如扣库存、发优惠券、发短信,这一类操作天生不能重复执行,消息一旦重投,用户就会收到两张券。
排查重复消费时,第一件事不是改代码,而是看消息里有没有全局唯一的消息 ID。没有唯一 ID 的话,你连去重都无从谈起。我的建议是,每个进入队列的 List 元素,都按“业务类型:业务主键:事件序号”这种格式生成。比如:
后续做任何幂等和审计,都依赖这个 ID。
4.2 消息消失的真相:BRPOP 一旦返回,数据就从 List 里删了
很多人会用 BRPOP 是因为它“阻塞等待,效率高”,但他们没意识到,BRPOP 返回的时候,这条消息已经从 Redis 的 List 里永久删除。如果消费者进程在处理消息的过程中宕机,这条消息就人间蒸发了。
我曾经在一个小项目里就踩过这个坑。消费者从 List 里取到消息后调第三方接口发通知,第三方接口超时,消费者进程直接被异常打崩,重启后再去看队列,发现一批消息已经没了。因为没有备份列表,那些消息找不回来,最后只能手动补数据。从那以后我给自己定了个规矩:只要是“处理完必须保证不丢”的消息,简单队列一律走 LMOVE + processing 列表;一旦业务进入对账、支付、订单这种级别,直接换上专业 MQ。
4.3 轻量幂等怎么设计
既然重复消费无法根除,那就从业务侧做幂等兜底。这里给三个由简到繁的方案。
第一,用关系数据库的唯一键。消息 ID 作为消费记录表的主键或唯一索引,消费前先 INSERT IGNORE。插入成功说明第一次消费,插不进去说明已经处理过,直接跳过。这是最简单也最稳妥的兜底方案。第二,用 Redis 本身做一个短期的消费记录。SET consumed:<msg_id> 1 EX 86400 NX,如果返回值不是成功标记,说明消息近期被消费过,略过即可。注意这个方案只适合短时间重复消费,长期历史去重还是要靠数据库。第三,把业务动作本身做成幂等。比如扣库存用版本号或者 CAS 指令,发券前先查用户是否已有同一张券,转账时以消息里的唯一流水号作为业务主键。能做到这一步,就算消息队列本身重复投递,也不会出现重复扣款。
5. 选型实战:Redis List、RabbitMQ、Kafka、RocketMQ 怎么选
5.1 先想清楚 Redis 队列的几条红线
用 Redis List 当队列开销极低,但必须清楚它的底线在哪里。
第一,内存就是队列长度的天花板。Redis 的数据全在内存里,如果生产速度暂时高于消费速度,List 会一路膨胀,直到触发 maxmemory 淘汰策略。队列淘汰消息,这在消息队列场景里是不可接受的。第二,持久化能力只能算“尽力而为”。RDB 快照有丢失窗口,AOF 默认每秒刷盘也可能丢最后一秒数据;Redis 主从切换时,客户端还可能在切换窗口里看到队列短暂不可用。第三,没有消费组的概念。多个消费者要分工消费不同消息,Redis 原生 List 做不到,你必须自己用分布式锁、分区 key 来分配,复杂度一路飙升。第四,没有消息确认机制。BRPOP/LPOP 返回即删除,“处理失败自动重试”这种事 Redis 不负责,必须自己用 processing 列表模拟。
正因为这些红线,我一般把 Redis List 队列定位成“非关键路径的轻量任务通道”。站内信通知、缓存预热指令、用户行为埋点临时缓冲,这种场景合适;核心交易链路上的消息,慎用。
5.2 四大队列对比与避坑要点
做一个简单粗暴的对比,方便你按场景拍板。
| 维度 | Redis List | RabbitMQ | Kafka | RocketMQ |
|---|---|---|---|---|
| 吞吐量 | 单实例万级 QPS 内 | 几万到十几万 | 百万级 | 十万到百万级 |
| 可靠性 | 弱,靠备份列表模拟 | 高,支持 ack 与持久化 | 高,但配置不当照样丢 | 高,事务消息能力强 |
| 消费组 | 无 | 有 | 有,天然分区并行 | 有,支持 Tag 过滤 |
| 重试/死信 | 自己实现 | 有死信队列 | offset 重置可重放 | 有重试队列 |
| 运维成本 | 极低 | 中等 | 较高 | 中等偏高 |
| 典型场景 | 轻量任务、通知、缓存 | 企业级异步、路由 | 日志、大数据流 | 交易、订单、电商 |
选型时我见过最多的坑是这么几个。RabbitMQ 的坑在于很多团队把手动 ACK 写成自动 ACK,消息一发给消费者就从 broker 里删了,业务处理失败也没法重试;另外死信队列配置漏了,重试次数一超消息就凭空消失。Kafka 的坑在于消费者位移提交时机没控好,开启自动提交且没关 enable.auto.commit,就会出现一批消息处理到一半消费者重启,导致重复消费。RocketMQ 的坑在于事务消息依赖消息回查,回查失败消息就卡在半成品状态,业务侧需要额外兜底任务。
一句话选型:消息不能丢、要精确一次、还要事务支持,直接考虑 RocketMQ 或 Kafka;要复杂路由和灵活的消息确认,RabbitMQ 更顺手;只是内部通知、任务列表这种低压力场景,Redis List 足够,不需要额外养一套集群。
5.3 混合架构:Redis List 当缓冲槽
最后说一个我比较推崇的用法:把 Redis List 当作消息系统的“缓冲槽”来用,而不是最终消息通道。尤其是流量有明显峰谷的场景,比如秒杀活动、热点事件推送。
做法很简单。生产者把请求先 LPUSH 到 Redis List,一个专用消费者进程每次从 List 里批量搬运几十或上百条消息,统一发送给后面的专业 MQ 或者批量写库。这样 Redis 只是承接了瞬时流量,真正的可靠通道和数据落地还是由专业组件完成。
这种模式的好处是:前端接口响应极快,List 的抗压能力足够扛住瞬时流量;专业 MQ 不会因为突发流量被打爆;消费者批量处理还能减少下游数据库的连接和事务次数。真要说风险,也就是 Redis 内存里会积压一批没搬走的数据,但只要消费者处理速度跟上,问题不大。这个思路比把业务直接挂在 List 上要稳得多。
最后说点我自己的体会。拿 Redis List 做消息队列,我用过,也吃过亏。我的原则很朴素:只把 List 用在“丢了也不致命、晚一点也无所谓”的场景,比如站内通知、任务缓冲、定时刷新;一旦涉及订单、支付、对账,老老实实上专业 MQ。另一个小习惯是每次上线前我会用 redis-cli --bigkeys 扫一遍大 key,看看有没有那种几十万元素的 List 被 LRANGE 一把梭。List 看着简单,真正把它用好,靠的是你对它的边界足够清楚。