Redis List实现消息队列:从底层原理到工程实践
写 Redis 数据结构这块,我一直觉得 List 是被低估最严重的那个。String 有缓存命中率可以吹,Hash 有对象存储可以吹,ZSet 有排行榜可以吹,List 呢?很多人背完 LPUSH、RPUSH、BRPOP 就觉得结束了,结果一到真实业务里就出问题:队列消息丢了、重复消费了、积压导致 Redis 变成大 key 了。这篇文章只围绕一个主线展开:用 List 实现消息队列,从底层原理到工程选型,再到重复消费、备份确认、积压监控这些实战细节全过一遍。适合同样在啃 Redis 数据结构的初学者,也适合准备后端面试、正在做轻量队列方案选型的同学对照着参考。
1. List 是什么:一个能从两端操作的序列容器
1.1 底层实现:从 ziplist 到 quicklist 的演进
面试里如果聊到 List 底层,最常听到的词是 quicklist。但很多人只是记住了名字,不清楚它到底是什么。
Redis 3.2 之前,List 有两种编码方式:元素少、值小时用 ziplist,也就是一块连续内存,省空间;元素多了、值大了,就切换成双向链表 linkedlist,每个元素单独分配一个节点。听起来合理,但问题也很明显:ziplist 每次插入删除都可能触发内存复制,双向链表每个节点都有额外指针开销,存 100 万个小整数时内存会被指针吃掉一大截。
Redis 3.2 引入了 quicklist,把这两种结构做了个组合。宏观上它还是一个双向链表,但链表的每个节点不再只存单个元素,而是里面塞了一个 ziplist。这样既保留了双链表两端快速插入删除的能力,又通过块内压缩减少了指针数量。到了 Redis 7.0,ziplist 被性能更稳的 listpack 彻底替代,quicklist 的节点内部也就变成了 listpack。
这里有一个参数值得你记住:list-max-listpack-size,默认 128。它控制的是 quicklist 里单个节点最多能装多少个元素。超过这个阈值,Redis 会新开一个节点继续装。如果消息体很小,可以适当调大这个值,让节点多塞一些数据,减少链表节点数量;如果消息体很大,反而要调小,避免单个节点占用连续内存过多。
1.2 基本命令:头插尾插、头删尾删、按索引查
List 的核心命令并不多,但每个都有适用场景,我把常用命令整理成了一张速查表,命令本身不复杂,看的时候注意时间和复杂度就行。
| 命令 | 作用 | 时间复杂度 | 使用提醒 |
|---|---|---|---|
| LPUSH / RPUSH | 从左/右侧插入一个或多个元素 | O(1) | 批量插入时顺序有讲究 |
| LPOP / RPOP | 从左/右侧弹出元素 | O(1) | 弹出即删除 |
| LRANGE | 取指定范围内的元素 | O(S+N) | S 是偏移量,区间别太大 |
| LINDEX | 按下标取元素 | O(N) | 长列表不推荐频繁使用 |
| LLEN | 获取列表长度 | O(1) | 监控队列积压经常用 |
| LTRIM | 只保留指定区间的元素 | O(N) | 适合限制队列长度 |
| LREM | 按值删除元素 | O(N) | count 参数负数代表从尾向头删 |
| LINSERT | 在指定元素前后插入 | O(N) | pivot 不存在返回 -1 |
| LPOS | 查找元素所在位置 | O(N) | 6.0.6+ 引入,支持 RANK/COUNT |
| BLPOP / BRPOP | 阻塞式弹出元素 | O(1) | 消息队列场景核心 |
| BRPOPLPUSH | 弹出并写入另一个列表 | O(1) | 可实现伪 ACK |
| LMPOP / BLMPOP | 一次弹出多个元素 | O(N) | 7.0+ 引入 |
如果你只是把 List 当数组用,LINDEX 和 LRANGE 是最直观的。但要注意,元素多的时候,LINDEX 需要从表头或表尾一路遍历过去,它是 O(N) 的,不是 O(1)。我在生产环境见过有人用 LRANGE 0 -1 去取一个几十万元素的列表,直接把 Redis 主线程卡了几百毫秒,那段时间所有读写请求都受影响。Redis 是单线程模型,这种操作要非常克制。
1.3 两个容易踩的命令坑
第一个坑是批量插入的顺序。LPUSH mylist a b c,最终列表从左到右是 c、b、a。为什么?因为 LPUSH 本质是逐条执行,先头插 a,再头插 b,再头插 c,最后 c 在列表最左侧。如果你想批量插入后保持 a、b、c 的顺序,要么用 RPUSH,要么反过来传参。这个细节我见过不少老手翻车。
第二个坑是同一端读写。LPUSH 配 LPOP,这是栈,后进先出;LPUSH 配 RPOP,这才是队列,先进先出。有人写代码时左手 LPUSH,右手 LPOP,跑起来发现消息顺序颠倒,一查就是方向没配对。队列约定要先想清楚:生产端往左进,消费端从右出,全链路保持一致。
2. List 作为消息队列的核心玩法:LPUSH + BRPOP
2.1 为什么要用 BRPOP 而不是 RPOP
既然 LPUSH 配 RPOP 已经是 FIFO 队列,为什么还要引入一个带 B 前缀的命令?B 就是 Blocking,阻塞。
如果消费端用 RPOP 去拉消息,消息没到的时候只能轮询:每隔几毫秒问一次 Redis“有没有数据”。一次两次没问题,几十个消费者同时轮询,Redis 连接数被打满,CPU 全耗在空转上。BRPOP 的解决思路是:让客户端阻塞挂起,等数据真正到达时由 Redis 主动唤醒它,把数据推过去。
BRPOP 的用法是 BRPOP key timeout,timeout 是阻塞超时秒数,0 表示永久阻塞。从时间复杂度和网络开销上看,BRPOP 都比轮询高效得多。真正带来收益的其实是线上可观测性:阻塞中的客户端连接状态稳定,不会再产生暴雨一样的空请求。
这里也需要说破一件事:BRPOP 阻塞的是当前连接,阻塞期间这个客户端连接上是发不了其他命令的。你要么只让这个连接专职消费,要么用短超时加循环,底下连接池多备几条给其他业务用。
2.2 生产者-消费者最小模型
一个能跑起来的 List 消息队列,核心就两行代码。
生产者:
消费者:
消费者收到的是一个数组,格式是 [队列名, 消息内容],例如 ["order:notify", "{"order_id":1001,"user_id":888}"]。拿到之后可以 JSON 解析,再交给业务处理。这个模型里,生产端和消费端不需要互相感知,天然完成了异步解耦。
真实业务里建议把队列名统一放到配置中心或常量池里,防止生产端和消费端各写各的命名。我接手过一个项目,生产端用的 key 是 order:notify,消费端却监听 order:notification,两边都不报错,消息全在 Redis 里睡大觉。这种问题排查起来的成本远高于一开始定好规范的成本。
2.3 阻塞唤醒与多消费者竞争的逻辑
多个 BRPOP 同时阻塞在同一个 key 上,来一条消息时谁消费?答案是只有一个客户端会醒过来拿到消息,其他客户端继续阻塞。分配顺序大体上按客户端进入阻塞状态的先后顺序来,先阻塞的先拿。不是你想象中大家一起抢,而是排队领号码牌。
这个特性决定了 List 队列不能靠无限增加消费者来提升吞吐。20 个消费者监听同一个 key,同一时刻也只有 1 个在处理消息,其余 19 个挂着当摆设。想要水平扩容,就只能做分片:拆出 queue:1、queue:2 一直到 queue:N,生产者按订单号哈希或者按 userId 取模决定投递到哪个分片,每个消费者固定监听一个分片。
Redis 官方对阻塞命令的唤醒机制做得很快,因为底层维护了 key 到阻塞客户端的映射表。当 LPUSH 一个消息进来,Redis 会立刻检查是否有阻塞客户端,有就第一时间把消息推给它,这个唤醒开销是常数级的,不用担心性能。
3. 队列可靠性与重复消费问题的正面拆解
3.1 消息丢失的两个层次
用 List 做消息队列,消息丢失会发生在两个层面。
第一个层面是持久化。默认配置下 Redis 是内存数据库,进程一重启,所有队列数据全部归零。你可以在 redis.conf 里打开 appendonly yes,把 appendfsync 设为 everysec,这样最多丢失 1 秒数据。但注意,这仍然不能保证 100% 不丢。
第二个层面是消费机制。BRPOP 拿到消息的同时,这条消息已经从列表里被删掉了。如果消费者在拿到消息后、业务处理完成前宕机,这条消息就再也找不回来。这就是消息队列里说的 at-most-once,最多投递一次。
如果业务能接受这种丢失,List 就够了。但如果不能接受,就需要把消费流程改造成 at-least-once,至少投递一次。至少投递一次也不完美,因为消息可能被多次处理,这会引出重复消费的问题,只能靠幂等来兜底。
3.2 备份队列方案:BRPOPLPUSH 实现的伪 ACK
要让 List 队列从“弹出即消失”变成“处理完才消失”,经典的方案是引入备份队列。
Redis 提供了一个组合命令 BRPOPLPUSH source destination timeout。它的意思是从 source 列表中 BRPOP 弹出,同时把这条消息 LPUSH 进 destination 列表。整个操作是原子的,不会出现弹出后崩溃导致消息凭空消失的问题。
用法很简单。消费者从业务队列读出消息后,不急着删除,而是让它先进备份队列。业务处理成功后,再执行 LREM 从备份队列里把这条消息删掉。如果消费端处理到一半崩溃了,消息还在备份队列里躺着,重启后可以用 LRANGE 扫描备份队列,把未确认的消息重新拉回业务队列处理。
Redis 6.2 之后提供了更灵活的 BLMOVE,可以指定从列表哪一端弹出、进入目标列表哪一端,功能上可以替代 BRPOPLPUSH。如果你的客户端库支持 BLMOVE,优先用新的。
注意:备份队列方案解决的是“消费者崩溃导致消息丢失”的问题,不是“Redis 自身崩溃导致全量丢失”的问题。要对抗后者,必须老老实实开持久化。备份队列不能穿越宕机。
3.3 重复消费的根源与解法:唯一 ID + 去重表
既然变成了至少投递一次,重复消费就不可避免。重复的来源主要有三个:生产者重试导致同一条消息被写了多遍;消费失败后重新入队;从备份队列恢复时把已处理的消息又处理了一遍。
Redis 自己不会帮你过滤重复,它根本没有这个机制。真正的解法是消费端幂等。我在工程里常用的套路是消息体中带一个全局唯一的 msg_id,消费端维护一个已处理 ID 集合,每次处理前先查,处理成功后再写入集合。
幂等集合如果数据量很大,可以把集合改成按天分片,上面代码里 done_key 就是按天拆的,配合 expire 防止 key 无限膨胀。删除备份时用的 LREM 是按值匹配的,如果备份列表里存在完全相同的两条消息,可能误删,所以消息体里必须带唯一 ID,并且尽量保证原样字符串唯一。
4. 该用 Redis 还是专业 MQ?选型对比与避坑指南
4.1 Redis 与主流消息队列的能力对比
互联网上讨论队列选型的帖子很多,很多人上来就说用 Kafka 还是 RabbitMQ,却把 Redis List 当成玩具。我的态度是:Redis 的队列能力确实不完整,但它足够快,足够简单,在合适的场景里就是最优解。你先得看清楚边界。
我把 Redis List/Stream、RabbitMQ、Kafka、RocketMQ 的核心差异整理成了一张选型对照表。
| 对比维度 | Redis List/Stream | RabbitMQ | Kafka | RocketMQ |
|---|---|---|---|---|
| 系统定位 | 内存 KV 附带的轻量队列能力 | 企业级 AMQP 消息中间件 | 分布式提交日志 | 金融级消息中间件 |
| 可靠性 | 依赖持久化配置;Stream 有 ACK 可做到消费状态不丢 | 高,消息确认机制成熟 | 高,分区副本 + ISR | 高,同步刷盘 + ACK |
| 吞吐能力 | 单实例十万级 ops | 几万到十几万级 | 百万级 | 十万到百万级 |
| 消费模型 | 阻塞弹出;Stream 支持消费组 | Queue/Binding 路由 | 消费组 + 分区位移 | 消费组 + 队列模型 |
| 顺序性 | List 天然 FIFO | 单队列内有序 | 单分区内有序 | 单队列内有序 |
| 延迟消息/事务 | 不支持,需业务自行实现 | 延迟消息靠插件,事务能力弱 | 均不支持 | 支持延迟消息和事务消息 |
| 运维成本 | 极低,复用 Redis | 中等 | 较高 | 较高 |
| 适合场景 | 内部异步通知、小流量削峰 | 业务解耦、任务分发 | 日志/大数据管道、事件溯源 | 交易类、订单类核心链路 |
这张表已经很说明问题了。Redis 的队列能力不是对标这些专业 MQ,而是占据一个“够用、轻量、快速上线”的空档。把它想成快递站门口的自提柜,而不是邮政分拣中心,就很好理解了。
4.2 什么场景下放心用 Redis 队列
我自己的判断标准有三条。
第一条,消息量可控。比如每天几万到几十万的内部通知类消息,完全在 Redis 单实例的射程范围内;如果每秒几万条往上冲,就要谨慎评估了,因为 List 的消费能力天然受制于单条弹出,积压速度可能超过消费速度。
第二条,业务对偶发丢失有容忍度。比如用户注册后发欢迎邮件、异步刷新某个聚合数据、订单完成后推送 APP 通知,少推送一次用户感知不强,业务也不会出大问题。
第三条,团队不想维护额外组件。很多中小项目里,Redis 已经是部署清单里必有的一项,再引入 RabbitMQ 或 Kafka,运维成本、监控成本和故障认知成本都会上升。能在一个核心组件里解决的问题,没必要拆成两个。
上面这种场景,用 List 做队列,三四天就能上线,不需要写复杂的配置,也不需要搭集群。我见过不少创业公司早期就用 LPUSH + BRPOP 撑过了第一轮业务验证,等量起来之后再切专业 MQ。
4.3 什么场景别碰 Redis 队列
反过来,有几种情况我会直接劝退。
第一类是资金相关、订单交易强一致性的链路。消息丢一条,账就对不上,这种需求应该交给支持事务消息、可靠 ACK 和消息回溯的 RocketMQ 或 Kafka。
第二类是需要死信队列、延迟队列、消息追踪、消费审计的场景。List 只能靠业务代码硬凑重试队列,延迟消息更是要自己写时间轮,成本高且容易出错。RabbitMQ 有现成的死信交换器和延迟消息插件,专业的事情交给专业的组件。
第三类是会出现消费端长期宕机的场景。如果消费者因为发布上线挂了两个小时,List 里的消息就以每小时几十万的速度积压,Redis 内存被打满,最终触发 OOM 或者大 key 阻塞,拖垮整个实例。Kafka 可以靠磁盘存海量数据,积压几天都不是问题;Redis 的内存模型决定了它不适合扛长时间积压。
选型时还要注意,Redis 不做消息过期清理。List 本身没有 TTL,消息积压了就只能靠消费端去消费,没有任何机制能自动淘汰旧消息。所以消息体里带上时间戳,消费时对超过处理时限的消息直接丢弃,是一种必要的自我保护。
5. 一套可落地的工程实践:带确认与监控的 List 队列
5.1 从零搭一个带伪 ACK 和幂等的完整队列
如果你决定用 List 队列,我建议代码不要停留在最小模型,至少把幂等、备份、重试、死信这些环节都考虑进去,否则上线后出现重复消费和消息丢失,你会非常被动。
先约定投递关系:生产端用 LPUSH 写入队列左侧,消费端用 BLMOVE 从队列右侧弹出,并把它放到备份队列左侧。业务成功后从备份队列删除。
生产端的实现我一般长这样:
消费端就是前面给出过的 consume_once 函数。这里补充两个细节。
一个是重试队列的处理。失败消息先推入 RETRY 队列,由单独的定时任务扫描重试队列,重新投递。如果重试超过 3 次,就直接进入 DEAD 队列,方便人工排查。重试队列本身也可以复用同样的备份确认机制,避免二次丢失。
另一个是幂等集合膨胀的问题。用 Set 记录已消费 ID 时,如果消息量很大,Set 会变得非常庞大,内存消耗不可忽视。我经常用按天分片的 key,并且对每条消息的幂等标记做 EXPIREAT,也就是让这个 key 在次日凌晨自动过期。这样做的好处是,你只关心最近一天内有没有处理过,更早的消息不需要永久记录。
5.2 队列积压监控与内存分析
List 队列最容易出事故的地方不是功能逻辑,而是积压。积压的直接后果是内存暴涨、消息延迟越来越大,严重时把 Redis 实例拖到 OOM。我建议把监控加进日常巡检脚本。
最简单的方法是周期性执行 LLEN 查看队列长度。
如果长度长期超过你预设的阈值,比如 10 万条,就要告警了。不要等到半夜磁盘告警才反应过来。
内存层面,可以用 INFO memory 看 used_memory,也可以定期用 redis-cli --bigkeys 扫描大 key。注意:不要在业务高峰期执行 --bigkeys,它需要遍历整个 key 空间,会有性能开销。
如果积压一旦发生,加消费者不一定解决问题,因为 List 单 key 的消费是串行的。更快的做法是,先停掉生产端流量,把积压消息用一个临时消费者分页取出、按业务 ID 重新投递到多个分片队列,再让多个消费者并行处理。说白了就是通过分片把单队列压力拆开。
5.3 性能参数调整建议
List 队列相关的调参主要有三个方向。
第一是 list-max-listpack-size。消息都很小的时候,把默认的 128 调到 256 甚至更高,能减少链表节点数量,降低指针开销。消息体大就不要动了,单个 listpack 节点太大反而浪费内存。
第二是持久化策略。前面说过,appendonly 一定要开,appendfsync 配置成 everysec 是可靠性和性能的折中。如果对可靠性要求高到连 1 秒都不能丢,那就 everysec,同时接受 TPS 下降的现实。Redis 的消息队列本质上是内存队列,不要跟它硬碰硬追求不丢。
第三是客户端超时参数。BRPOP 和 BLMOVE 的 timeout 不要设置成 0 永久阻塞。很多客户端库里,永久阻塞一旦遇到网络闪断,重连逻辑反而会变得不可控。我习惯设置 5 秒以内的超时,超时后返回空,循环继续,这样也能更早暴露连接异常。
6. 常见问题排查与命令细节备忘
6.1 高频排障速查表
用 List 做队列的时间久了,我总结了一张自己的排障速查表,每次出问题先照着排查一遍,大部分都能定位到根因。
| 现象 | 大概率原因 | 排查手段 | 处理方案 |
|---|---|---|---|
| Redis 重启后队列消息全没了 | 未开启 appendonly 持久化 | config get appendonly | 开启 appendonly yes |
| BRPOP 一直等待但队列里有数据 | 生产端和消费端方向不一致,一边 LPUSH 一边 LPOP | LRANGE 看列表内容和方向 | 统一一头进一头出的约定 |
| 队列积压快速增长 | 消费者宕机或消费速度跟不上 | LLEN 看积压量,INFO clients 看消费者连接 | 扩容分片队列,排查消费者线程 |
| 同一条消息被处理多次 | 生产端重复投递,或者备份恢复时重复消费 | 检查消息 msg_id 和幂等日志 | 消费端做幂等去重 |
| LRANGE 取全列表导致 Redis 卡顿 | 大 key 加上大范围遍历 | redis-cli --bigkeys 扫描 | 分批取数,消息量级大时避免一次性拉取 |
| 备份队列里的消息删不掉 | LREM 的 count 参数传错 | 检查 count 正值负值 | count=0 删除全部匹配 |
第二类现象特别常见。你写了一个队列,LRANGE 看到的列表顺序好像没问题,但消费者就是取不到某些消息,其实是因为同一端进出把队列变成了栈。遇到问题第一步不是改代码,而是用 LRANGE 0 -1 看看列表的真实顺序,再对着生产端和消费端的命令方向检查一遍,通常一分钟就能发现问题。
6.2 几个容易记混的进阶命令
LPOS 是 Redis 6.0.6 引入的查找命令,可以找出某个元素在列表里的位置。它支持 RANK 指定从哪一侧开始找,COUNT 指定最多返回几个匹配位置,MAXLEN 限制扫描长度。要找一个值是不是大列表里存在,LPOS 比 LRANGE 全量扫描聪明得多。
LMPOP 是 Redis 7.0 引入的多元素弹出命令,可以一次从多个 key 里弹出指定数量的元素。它的典型场景是批量消费:一次取 50 条消息,减少网络往返。但要注意,批量取出后一旦业务崩溃,这 50 条消息都停在备份队列里,恢复逻辑要按批次处理,幂等集合依然是最重要的兜底。
BLMOVE 从 Redis 6.2 开始成为 BRPOPLPUSH 的升级替代。它最大的改进是可以自由指定源队列和目标队列的左右端点。如果你还在用旧客户端或者担心版本兼容问题,BRPOPLPUSH 也没问题,语义上是它的一个子集。
Stream 是 Redis 5.0 引入的消息队列全新数据类型,支持消费组、pending 列表、XACK、XCLAIM,从能力和可靠性上完全不同于 List 队列。如果团队用的是 Redis 5.0 以上版本,而且业务开始出现“多个消费组”或“消费状态精细管理”的需求,Stream 是比 List 更合适的选择。
最后再分享一个我自己的习惯:只要是用 Redis 做队列,监控脚本里一定会带上 LLEN 和队列积压增长率的检查,任何一个 key 的长度在短时间内翻倍,我宁可先报警再说,也不想等出事了再去翻日志。用 List 做队列的性价比在于轻,但也正因为它轻,消息丢失、重复、积压这些问题的防线全部要自己搭。前期花一点时间把备份、幂等、死信、监控四个环节补齐,后面能省掉无数个被线上故障支配的深夜。这套链路跑熟之后,再切换到 Stream 或者专业 MQ,你对“可靠性”的理解也会完全不一样。