Redis不只是缓存:五大数据结构的高并发实战场景
Redis 不会只当缓存用的,它那五个数据结构,每一根都硬邦邦的。我最早接触 Redis 的时候,跟大多数人一样,GET、SET、EXPIRE 三板斧,不就是个带超时时间的 HashMap 嘛,K/V 缓存嘛,存个验证码、存个 token、顶多加个布隆过滤器挡一下穿透,仅此而已。直到有一次做活动,线上流量把数据库拖垮了,缓存的缓存击穿、缓存雪崩连环暴击,我被迫去翻 Redis 的底层数据结构源码,才发现这东西的定位根本不是"缓存中间件",而是一个内存数据结构服务器。它给你的不是一个简单的字典,而是 String、List、Hash、Set、ZSet 这五套自带操作原语的数据结构,你完全可以用它去实现分布式锁、延迟队列、排行榜、附近的人、UV 统计、消息队列、全局 ID 生成器……全都是在内存里完成的,快到你根本不需要去依赖那些额外的中间件。
说白了,Redis 是一个披着缓存外衣的数据结构服务器。同一个 Redis,有人用它扛住了双十一的流量,有人用它实现了 B 站风格的弹幕系统,还有人只是把它当成 MySQL 前面的挡箭牌。这两种做法之间的差距,不在于 Redis 本身,而在于你是否真的吃透了它的数据结构。下面这 10 个场景,是我在真实项目中验证过不止一遍的,涵盖了高并发抢购、实时排名、分布式会话、毫秒级统计、地理位置检索等大半个后端开发的硬需求,你挨个看完,应该会发现系统的很多瓶颈,其实根本不用加机器,把 Redis 的姿势换个角度就化解了。
1. 先聊思路:为什么 Redis 能玩出这么多花样
1.1 五大基础数据结构对应的核心问题域
聊场景之前,得先把 Redis 的"内功心法"摆出来。很多人把 Redis 当成一个大号的 Map,这是对的,但又不全对。Redis 的真正威力在于,它的 Value 本身就是有"形状"的,每一种形状都对应着一类经典问题:
- String(字符串):不只是缓存字符串,还能自增自减(
INCR/DECR),所以它能做计数器、限流器、分布式 ID、库存扣减。 - List(列表):双向链表,支持头尾插入弹出,天然适合做消息队列的轻量版(
LPUSH+BRPOP),也适合做时间线、操作日志等"先进先出后进先出"的场景。 - Hash(哈希):相当于嵌套的 Map,特别适合存对象字段,比如用户信息、商品信息、购物车,避免了反复
JSON序列化整个对象的浪费。 - Set(集合):无序去重,天然支持求交集、并集、差集,适合做标签系统、共同好友、好友关注关系。
- ZSet(有序集合):每一个元素带一个 score,按分数排序,这是 Redis 里最"作弊"的数据结构,排行榜、延迟队列、滑动窗口限流全靠它。
所以,你看,同一个 Redis,只要你把这五根"柱子"用对了,它就不只是一个缓存层,而是一套轻量级的内存计算引擎。
1.2 从"缓存思维"到"数据结构思维"的转变
这里我建议你做一个思想实验:你现在要做一个抽奖活动,用户签到、做任务、消耗积分,然后可以参与抽奖。如果是"缓存思维",你会怎么设计?把用户信息、积分、签到记录全部都塞进各种奇怪的 Key 里,然后自己写一堆业务逻辑去串。但如果是"数据结构思维",你会怎么设计?
- 用户积分用一个
ZSet维护,score就是积分值,天然就能按积分排行。 - 用户签到用一个
String按天做 bit 位(比如sign:20250101),每天的 bit 位记录签没签。 - 抽奖记录用一个
List做流水,或者用Set做去重防止超抽。
你会发现,结构即业务。当你的数据以最合适的结构存在时,很多"算法"和"业务逻辑"其实就是 Redis 自带的一个命令而已。这就是我把这些场景串起来的思路——不是给你讲 10 个孤立的技巧,而是让你把这五大数据结构当成一套工具箱,看到什么业务问题,脑子里第一反应是"这能用哪个 Redis 结构来解决"。
2. 高并发硬仗:分布式锁与限流
2.1 分布式锁:从 setnx 到 Redisson 的完整演进
先讲分布式锁,这是 Redis 在企业级项目里最被低估的使用场景之一。为什么需要分布式锁?因为你一旦上了多实例、多服务节点,JVM 自带的 synchronized 就锁不住了——每个实例都有自己的一把锁,根本不可能互斥。这时候就需要一个所有实例都能访问的"中央锁",Redis 就是最自然的选型。
最原始的姿势是 SETNX(SET if Not eXists)命令:如果 Key 不存在就设置成功,返回 1;如果存在就设置失败,返回 0。这个命令单看没什么问题,但实操中坑一堆:假如线程 A 拿到锁之后处理业务,处理到一半进程发生了 GC 停顿、网络延迟,锁一直没释放,其他线程全卡死。于是大家开始加超时时间,SET key value NX EX 30,意思是 30 秒必须放锁。但新的问题又来了:如果线程 A 的业务逻辑超过 30 秒,锁自动释放了,线程 B 抢到锁开始执行业务,这个时候线程 A 终于执行完了,它又手动执行 DEL 把锁删了——这就会导致线程 B 的锁被线程 A 误删,两个线程同时进入了临界区,互斥性彻底失效。
解决误删的办法很经典:在 Value 里存放一个唯一标识(比如 UUID),删除之前先 GET 一下,看看是不是自己的锁,是自己的才删。但你再仔细一想,"GET + 判断 + DEL"这三个操作并不是原子的,中间依然有被穿插执行的窗口。正确做法是引入 Lua 脚本来保证原子性:
这个 Lua 脚本在 Redis 服务端是一个原子操作,不会被打断。你以为到这算完了?还早。如果是 Redis 主从架构,线程 A 在主节点拿到了锁,主节点还没来得及同步到从节点就宕机了,从节点顶上成了新的主节点,锁信息丢失,线程 B 再来 SETNX,照样能拿到锁——互斥性再次被突破。Redis 官方对此给出的方案叫 RedLock(红锁算法),意思是你得部署多个完全独立的 Redis 节点,加锁的时候要向超过半数的节点同时加锁,才算加锁成功。但这个方案在业界一直有争议,因为它在极端场景下依然不是"绝对安全"。
所以我的个人建议是这样的分层策略:
- 业务允许偶发重叠(比如有些非关键任务、异步补偿),直接用 Redis 单节点锁 + 超时时间 + 唯一标识 + Lua 释放,简单高效。
- 业务绝对不允许重叠(比如发放余额、扣减库存),不要过度依赖 Redis 锁,改用数据库乐观锁或 ZooKeeper 临时顺序节点,配合事务,保证最终正确。
- 如果一定用 Redis 且业务要求较高,直接上 Redisson 客户端。它封装好了看门狗机制——如果你的业务没执行完,它会自动帮你续期锁,类似"护锁线程",避免锁提前过期的问题。
我们团队真实遇到过一个问题:锁过期时间设置得太短(10 秒),导致大量任务并发失败。后来换了 Redisson,它的看门狗默认 30 秒做一次续期,直接解决了这个痛点。还有一次是锁粒度过粗,一个用户的所有操作共用一个写锁,导致请求排队严重,当时把锁粒度从"用户级"降到"账户级"、甚至"订单级",性能才彻底释放。分布式锁的粒度设计,很可能比锁本身更重要。
2.2 限流实战:基于计数器的滑动窗口实现
前面说的是"锁",现在讲"闸"——限流。限流的核心思想是控制单位时间内的请求量,防止热点事件把后端冲垮。用 Redis 实现限流,最原始的方式是固定窗口:用 INCR + EXPIRE,比如一个用户 1 分钟最多 100 次请求。
这个方案有一个著名的"临界点问题":第 59 秒来了 100 个请求,第 61 秒窗口重置后又来了 100 个请求,跨窗口瞬间实际是 200 个请求通过了。所以固定窗口限流在大流量下并不严谨。
更严谨的做法是滑动窗口:用 ZSet 记录每次请求的时间戳,然后每次都去统计"当前时间往前数 60 秒内"的请求数。伪代码如下:
这个方案统计精确,能够避免固定窗口的临界点问题,同时用 PEXPIRE 保证不用的 Key 自动清理掉。当然,ZSet 的每一个请求都会存一条记录,大流量下内存消耗不小。如果对内存要求高,可以退一步用多个桶(比如每秒一个桶,按秒做 INCR),把精度从 1 分钟降到 1 秒,用更多 Mem 换精度,这也是我常用的折中方案。
实际踩坑提醒一下:
- 记得给 Key 设置过期时间,否则用户量一大,Redis 里全是废 Key,内存爆掉。
- 限流和"负载保护"不同,它需要返回值告诉调用方"你被限流了,请重试",而不是让调用方直接超时。
- 生产环境不要用
INCR之后判断是否大于阈值,而应该用 Lua 脚本把"检查+自增+判断"拉成一个原子操作,防止并发下超发。
3. 统计类场景:HyperLogLog、位图与排行榜
3.1 用 HyperLogLog 做 UV 统计,12KB 撑起千万级去重
我做活动平台的时候,流量最大的一块需求就是 PV/UV 统计。PV 好说,一个 Redis 计数器就搞定了,INCR 完事。但 UV 有一个去重逻辑——同一个用户在 24 小时内多次访问只能算一个 UV。如果用户量是百万级甚至千万级,你把每个用户 ID 都存进一个 Set 里去重,内存分分钟爆炸。这时候就该 HyperLogLog 登场了。
Redis 提供 PFADD 和 PFCOUNT 两个命令。
HyperLogLog 的底层原理是"概率计数",它用极小的固定内存(每个 Key 大约 12KB)来估算一个集合中的唯一元素个数,标准误差为 0.81%。这是什么概念?1 亿个 UV 的数字,估算出来可能是 9900 万,也可能是 10100 万,对于大多数运营报表来说完全够用。而且它支持多 Key 合并(PFMERGE),可以很方便地把一周的数据合并成一个月的汇总。
当然要分场景:如果统计结果是直接用钱结算的(比如广告曝光计费),那还是老老实实上 Set 精确统计,别用概率结构挑战财务底线。如果是给运营看趋势、看量级的,直接上 HyperLogLog,性价比无敌。
3.2 位图实战:签到统计与亿级在线状态
位图这个场景知道的人少,但杀伤力极大。Redis 的 String 底层是一个字节数组,你可以用 SETBIT/GETBIT 命令操作二进制位。比如做一个用户签到功能,一年 365 天,你只需要 365 个 bit,大约 46 个字节,就能记录一个用户一整年的签到记录。一亿个用户一年的签到记录,总内存只有 4.6GB,而且查询某一天有没有签到是 O(1) 的复杂度。
具体设计:
除了签到,位图还能做亿级用户在线状态管理。每个用户对应一个 bit,0 表示离线,1 表示在线,SETBIT online:20250101 12345 1 标记用户上线,BITCOUNT 就能实时统计全站在线人数。我之前给一个大后台做过这个功能,以前用 MySQL UPDATE 更新在线状态并发扛不住,换位图之后,统计从分钟级变成毫秒级,内存开销还小得恐怖。
3.3 排行榜:Sorted Set 就是为这事生的
排行榜可能是 Redis 用得最爽的场景。ZSet 的每个元素带一个 score,Redis 会自动按分数排序,天然支持排行榜。以游戏排行榜为例:
排行榜有一个经典问题:如果分数相同怎么办?你想让"分数相同的人,先达到这个分数的人排在前面",一个常见技巧是把 score 变成一个小数:整数部分是分数,小数部分是时间戳的倒序。比如分数 1000、达成时间戳 1700000000,那么你存的 score 可以用 1000.999999999 这样的组合(具体精度需要按业务调)。还有一种方案是 ZINCRBY 加分后,再维护一个"达成时间"的 ZSet,前端同时读两个榜单,按分数排序后再按时间排序。两种方案各有优劣,但都能解决"并列排名"的展示问题。
再提一句,排序在百万级数据时性能依然极好,因为 Redis 的跳表(skip list)结构,增删改查几乎都是 O(log N) 级别,这是 MySQL 的 ORDER BY 在实时榜单场景下完全无法比拟的。
4. 业务功能场景:GEO、延迟队列与轻量消息队列
4.1 GEO:附近的人、门店推荐与配送调度
Redis 3.2 引入了 GEO 功能,底层实现还是基于 ZSet,但它直接封装了地理解析和距离计算,用起来极其顺手。你可以用 GEOADD 把一批门店的位置丢进去,然后用 GEOSEARCH(Redis 6.2 版本新命令,比旧版 GEORADIUS 更准确)查找附近指定半径内的门店。
这个功能的经典应用不只是"附近的人",还包括外卖的"附近商家"、共享单车的"附近空闲车辆"、快递的"配送路线规划"。需要注意一点:GEO 的经纬度都是用户输入的,存在脏数据很可能导致距离计算失真,所以写入时要做好边界校验。另外,如果要支持大规模的"实时车辆位置更新",你不能随意 ZREM 然后再 GEOADD,因为频繁的写操作会导致跳表提前旋转,性能下降。更好的做法是批量写入、降低更新频率。
4.2 延迟队列:订单超时自动取消与定时任务调度
延迟队列是一个被我低估了很久的场景。需求长这样:用户下单后 15 分钟未支付,系统自动取消订单;视频发布后 1 小时自动转码;活动开始前 30 分钟给所有参与者发送提醒。这类"延时任务"从实现方式上讲,无非是三种路线:
- 用定时任务轮询数据库,缺点:DB 压力大、延迟不精确、积压任务多了会变成对 DB 的轮询轰炸。
- 用消息队列的延迟消息(比如 RabbitMQ 的 TTL + 死信队列),需要额外引入组件。
- 用 Redis 的 ZSet 实现延迟队列,性价比最高。
用 ZSet 实现的思路很简单:score 存放任务执行的时间戳,value 存放任务内容。然后启动一个轮询任务,每秒查一次 ZSet 中 score 小于等于当前时间的记录,取出并执行。伪代码如下:
这套方案的优点是不需要额外引入中间件,直接用现有的 Redis 就能搞。但有几个坑你要注意:
- 如果你只用一个 Redis Key,并发消费时要小心多个 worker 同时取出同一个任务。我用
ZREM的返回值来判断:ZREM返回 1 表示当前 worker 抢到了,返回 0 表示任务已经被其他 worker 拿走了。 - 轮询间隔不要太短,否则 Redis 会被无意义的空查询打满。一般 1 秒轮询一次就够,如果想精确到毫秒级,再考虑引入更专精的延迟队列中间件。
- ZSet 里的 value 建议放一个 JSON 序列化后的任务 DTO,并包含任务唯一 ID、业务参数、重试次数,方便失败后重新投递。
我们在做订单超时场景时,实测用这个方案处理了日均千万级的延迟任务,Redis 实例的 CPU 使用率依然很低,而且代码量比引入新中间件少了一个数量级。
4.3 Stream 与 List 做消息队列的取舍
聊到消息队列,很多人第一反应是 Kafka 或 RabbitMQ,但别忘了 Redis 本身就提供了 List 类型的阻塞队列原语。LPUSH + BRPOP 就是一套最简单、最可靠的生产者-消费者模型。
这套方案的优点是一个命令就能实现消息的入队与消费,且天然支持 FIFO(先进先出),如果你只是想要一个轻量的任务队列,不要求消息不丢失、不要求精准消费,那这已经够用。但注意,它有一个致命弱点:一旦消费者崩溃,从 List 里弹出的消息就永久丢失了,因为 BRPOP 是"弹出即删除"。如果你需要消费确认、消息回溯、消费者组的能力,必须上 Redis 5.0 推出的 Stream。
Stream 是 Redis 官方的消息队列,提供了 XADD、XREADGROUP、XACK 等命令,支持消费者组(多个消费者分摊消息、支持消息 ACK),支持消息持久化(配合 RDB/AOF),还支持 PEL(Pending Entries List,待处理消息列表)来处理消费失败。我在项目里用过 Stream 做过一个中等规模的告警消息通道,整体比 List 放心很多,因为你可以明确知道哪些消息被谁消费了、哪些卡在 PEL 里等重试。
做个简单的选型表给你参考:
| 方案 | 优势 | 劣势 | 适合场景 |
|---|---|---|---|
| List + BRPOP | 简单直接,无额外学习成本 | 消息无 ACK 机制,消费端崩溃会丢消息 | 日志收集、内部任务调度、数据上报 |
| Redis Stream | 支持消费者组、消息确认、持久化 | 需要 Redis 5.0+,客户端 API 稍重 | 较大体量任务分发、可靠消息投递 |
| Kafka / RabbitMQ | 高吞吐、持久化、多副本、生态完善 | 需要独立部署,运维成本高 | 企业级数据管道、核心交易消息 |
这里我想强调一个容易被忽视的点:Redis 的 List 和 Stream 都不适合保存无限增长的消息流。这些数据是存在内存里的,如果生产速度一直大于消费速度,内存会持续膨胀。所以要么控制消息的 TTL,要么定期清理,要么干脆换 Kafka。Redis 官方也有提醒,它定位是低延迟的"轻量中间件",不是高吞吐的"大硬盘"。
5. 会话与 ID 生成:Redis 的分布式隐藏技能
5.1 Session 共享:多实例登录态的统一管理
我这些年接手的项目中,几乎每个都有"Session 不一致"的问题。原来单体应用,用户登录后把用户信息塞进 Tomcat 的 HttpSession,单机没问题。后来上了多实例,用 Nginx 做负载均衡,用户第一次请求落在 A 实例登录成功,第二次请求被转发到 B 实例,B 实例发现没有他的 Session,就要求重新登录。这种体验做一次,用户就流失了。
解决 Session 共享的通用姿势是 Spring Session Data Redis:把原本存储在本地的 Session 数据全部转移到 Redis。用户登录后,Session 信息写入 Redis,应用层只需要根据 Session ID 去 Redis 里取数据,不管请求落在哪台机器上,都能拿到同一条 Session。这其实也是"缓存"思维的一个延伸:把一个有状态的应用变成了无状态服务,非常关键。
官网的实践细节有几个:
- 立一个全局的 Session 前缀(比如
spring:session:),设置合理的过期时间,比如登录态 2 小时。 - Redis 中存的是 Session 属性的序列化结果,注意 序列化器的配置。默认的 JDK 序列化导致存储的数据肉眼不可读,我一般改成 JSON 序列化(GenericJackson2JsonRedisSerializer),可读性好,排查问题方便,内存也小一大截。
- 应对"踢人下线、强制刷新在线列表"等需求时,可以给每个用户多维护一个
ZSet(key 存用户 ID,score 存登录时间),既能找到用户所有在线 Session,又能精确控制某个 Session 的失效。
Redis 会话共享最突出的价值不是省了几台服务器,而是让应用彻底无状态,只有无状态才能平滑水平扩展。我从踩坑中悟出的一句话:做分布式之前,先把本地的 HttpSession 关掉,因为你永远不知道流量会打到哪台机器上。
5.2 分布式 ID:用 INCR 的全局唯一流水号
最后一个场景是分布式 ID 生成。正常的单体项目用 MySQL 自增 ID 就够了,但在分布式场景下,多个服务节点各自生成 ID,冲突是必然的。业界常用的方案有雪花算法(Snowflake)、UUID、数据库号段,但 Redis 也可以当 ID 生成器用,而且实现极简单。
INCR(或 INCRBY)返回自增后的值,命令本身是原子的,多线程多实例并发调用时不会重复。Redis 官方也专门为这种场景提供了 INCRBY 配合 EXPIRE 的用法。举个例子:生成订单号,你需要"年月日 + 当日序号",可以每天一个 Key(order:seq:20250101),INCR 后拼上日期前缀,就得到形如 2025010100012345 的订单号。
注意这里的卧龙与凤雏并存的坑:
- 单点问题:如果 Redis 宕机,你的 ID 生成器就挂了,而且可能存在"回拨风险"(Redis 拿到的值是最后一次落盘的 AOF 快照之后的值)。如果 ID 生成器对你来说是核心链路,必须给 Redis 做主从,并且设置合理持久化策略。
- 趋势递增 ≠ 严格递增:多线程情况下通过同一个 Redis
INCR生成的 ID 是趋势递增的,但并不保证严格连续,这通常没问题,但你别指望它能当数据库主键用(虽然大多数时候能用)。 - 如果追求极端性能,可以把"拿号"和"取号"分离:先从 Redis 取一个号段(比如
INCRBY range:key 1000),然后在本地内存里自增 1000 个 ID 再回 Redis 拿下一段,这样就把 Redis 的压力下降了千倍。这个方案还有个名字,叫"redis 号段模式”,很多公司的发号器就是这么做的。
Redis 分布式 ID 的好处是:实现简单、低延迟、不依赖第三方组件,对绝大多数写操作不频繁的业务,完全够用。如果你对唯一性要求极高,同时要避免时钟回拨,那就用雪花算法——但如果追求简单,Redis 已经能扛住主流的业务规模了。
6. 聊聊我在实际项目中的选型心得
最后说点我自己的体会。用 Redis 最重要的不是记命令,而是建立"结构驱动设计"的直觉。我现在拿到一个需求,第一反应不是去建表,而是先想:这个数据形态最适合用 Redis 的哪种结构?是 ZSet(带权重的有序集合)、是 HyperLogLog(应对海量去重)还是位图(压缩状态信息)?数据结构选对了,后面所有逻辑都是水到渠成。
举一个我印象很深的例子:有一次做排行榜优化,原项目用 MySQL 表存了上百万条积分数据,每次榜单接口要跑好几秒,还被运营疯狂吐槽。我迁移到 Redis ZSet 之后,线上最高负载 2000 QPS 时榜单接口 P99 延迟只有 20ms 左右。这种性能飞跃不是我多厉害,而是 Redis 的结构天生就是干这个事的。
还要强调一点,Redis 虽然牛,但它不是银弹,尤其别把它当成万能存储。内存成本比磁盘高一个量级,Redis 的数据量一旦接近物理内存,性能就会雪崩(因为要触发淘汰策略或 swap)。所以我给自己的规则是:
- 能用消息队列解决的(真的需要 ACK、持久化),不用 Redis 硬顶。
- 能用数据库解决的(不追求极低延迟、需要复杂查询),不强行塞 Redis。
- Redis 里只放热数据和结构有天然优势的数据,比如排行榜、延迟队列、计数器、分布式锁。
最后,你如果真的想精通 Redis,建议自己动手把源码里那几个数据结构源码啃一遍,至少搞清楚:List 的 quicklist、ZSet 的 skip list、Hash 的 ziplist/ hash table 这些底层结构在什么条件下会切换。搞懂了底层,你自然就明白为什么"大数据量的 ZSet 排序依然快""为什么 Hash 字段少时内存更省"" 为什么排行榜用 ZSet 而不是用数据库"——这些答案全都在源码里。等你吃透这些,Redis 就真的不只是一个"缓存"了,而是你工具箱里最锋利的一把刀。