先说一个很典型的现场。首页的热销榜,按销量倒序取前 20,数据放在 MySQL。最初就是一条 SELECT ... ORDER BY sales DESC LIMIT 20,商品表 40 万行,日销量表 300 万行。压测到 800 QPS 时,数据库 CPU 到 92%,接口 P99 变成 1.2 秒。慢日志里这条 SQL 每次要扫 40 万行再排序,销量列上没有索引;就算加上,销量每秒都在变,索引页也一直在改,写反而更慢。

后来把榜单搬进 Redis 的一个 ZSet:商品上架时写入一个初始分,有成交就 ZINCRBY。读接口变成一条范围命令,P99 20ms,数据库 CPU 回到 30%。同一份数据,换了一种摆法,代价是榜单和数据库之间多了一条同步逻辑,还要接受 Redis 重启时榜单可能短暂为空。

这篇就是从这个场景往下走:先把连接和库搞清楚,再把五种结构一个个用命令摸一遍,最后用四个真实需求串起来,看每种结构在什么位置、会把什么坑留给你。文中所有命令和输出都没有在本机实测,本机没有安装 redis-cli 和 Redis 服务;输出按 Redis 7.x 的语义写,你实际执行时以返回为准。

先连上去,确认在对的库

Redis 的客户端叫 redis-cli,最常用的两个参数是地址和端口。连上之后第一件事不是敲命令,是确认自己连到了哪个实例、哪个库。

redis-cli -h 127.0.0.1 -p 6379
PING
PONG
SELECT 1
OK
DBSIZE
(integer) 0
INFO keyspace
# Keyspace
db0:keys=12,expires=3,avg_ttl=3600000

PING 返回 PONG 说明服务活着。默认有 16 个库,编号 0 到 15,SELECT 切库,DBSIZE 返回当前库的 key 数量,复杂度是 O(1),因为它只读一个计数器,不遍历。集群模式下只有 0 号库,SELECT 会直接报错。

生产上不要拿 db 做业务隔离。切库是连接级的,一个连接池里不同线程切来切去很容易写错地方,而且集群不支持。正确做法是用 key 前缀,比如 order:20261106:123,再用 ACL 按前缀授权。

排查时先看 INFO keyspace,确认数据到底在哪个库、有没有过期 key 堆积,比上来就 KEYS * 安全得多。KEYS 会遍历全库,千万级 key 时能把实例卡死,线上用 SCAN 加游标分批。

五种结构,其实是五种排法

Redis 的 key 永远是字符串,差别在 value 的形状。五种结构不是五个语法糖,它们各自维护了一种顺序,你选结构其实是在选「以后按什么顺序取」。

结构一个 key 里装什么有序依据典型用途
String一个值,可以是文本、数字或二进制无整块缓存、计数器、分布式锁
Hash一组字段到值的映射无,按字段名取对象、购物车、文章计数
List一个双向链表插入位置队列、最新 N 条
Set一个去重集合无,但支持交并差点赞去重、共同关注
ZSet每个成员带一个分数分数,分数相同按成员字典序排行榜、延迟队列

只有 ZSet 是「写进去就替你排好」的,其余四种要么无序,要么顺序只跟插入位置有关。这也解释了为什么排行榜一定要用 ZSet:用 List 也能存排名,但每次有人加分你都得自己重新插一遍,而 ZSet 每次写入是 O(log N)。

还有一层看不见的差别:五种结构在元素少的时候都会尽量用紧凑编码。String 的短值用 embstr、整数值用 int;List、Hash、ZSet 元素少时用 listpack;Set 全是整数且数量不多时用 intset。超过阈值就换成 quicklist、hashtable 或跳表。阈值随版本和单个元素大小变化,具体数值以 CONFIG GET 的结果为准,待确认。

String 与 Hash:值、计数、对象

String 是最基础的一种,一个 key 对应一个值。它能存文本、整数、序列化后的 JSON,也能当位图用。最常用的几类操作是读写、自增、过期。

SET user:1001:name "张三"
OK
GET user:1001:name
"张三"
SET views:home 0
OK
INCR views:home
(integer) 1
INCRBY views:home 10
(integer) 11
EXPIRE user:1001:name 3600
(integer) 1
TTL user:1001:name
(integer) 3594

INCR 是原子的,多个客户端同时加不会丢。这是它和「读出来加一再写回去」最大的区别,后者在并发下一定丢更新。SET 还能带参数做「不存在才写」和「带过期时间一次写完」,这两条组合起来就是最简单的分布式锁,后面会细讲。

String 存对象的问题是:改一个字段要整块读出来、改完再整块写回去。两个人同时改不同字段,后写的会把先写的覆盖掉。所以只要对象有多个会被独立修改的字段,就该换成 Hash。

HSET user:1001 name 张三 age 28 city 杭州
(integer) 3
HGET user:1001 name
"张三"
HGETALL user:1001
1) "name"
2) "张三"
3) "age"
4) "28"
5) "city"
6) "杭州"
HINCRBY user:1001 age 1
(integer) 29
HLEN user:1001
(integer) 3

Hash 的好处是字段级读写:改年龄不影响昵称,取昵称不用把整个对象拉回来。它适合「字段数量有限、经常只读其中几个」的对象。但它不是文档库:不能按字段值查询,不能对字段做范围扫描,也没有二级索引。要「找出年龄大于 30 的所有用户」,Hash 帮不了你。

这里还有一个容易被忽略的点:同一个结构在元素变多之后会换一种内部编码。Hash 在字段少且值短的时候用 listpack 存,省内存;超过阈值就转成真正的哈希表。常见默认阈值是字段数 128、单个值 64 字节,具体随版本变化,待确认,可以用 CONFIG GET hash-max-listpack-entries 查当前值。编码换了,单条命令的耗时和内存占用都会变,这也是小测试环境和大生产表现不一致的常见原因。

List 与 Set:队列、去重、交集

List 是一个双向链表,两头都能进出,所以既能当队列也能当栈。它最常用的场景是「先进先出的任务队列」和「只保留最近 N 条」。

LPUSH queue:email task1 task2
(integer) 2
LRANGE queue:email 0 -1
1) "task2"
2) "task1"
BRPOP queue:email 5
1) "queue:email"
2) "task1"
LLEN queue:email
(integer) 1

LPUSH 从左进,BRPOP 从右出,合起来就是先进先出。BRPOP 的最后一个参数是超时秒数,队列空的时候会阻塞等待,最多等 5 秒,返回 nil。这比客户端轮询省资源,也是 Redis 常被拿来做轻量队列的原因。

但它不是可靠队列:消费者取走消息后如果进程崩了,消息就没了,没有确认机制,也没有消费组。要「取走但没处理完还能放回去」,得用 LMOVE 把消息挪到一个处理中的列表,处理完再删;要正经的消费组和确认,用 Stream 的 XREADGROUP,或者干脆上专门的消息队列。

Set 是无序去重集合,最大的价值是判断「在不在」和做交并差。

SADD post:1001:likes 2001 2002 2003
(integer) 3
SADD post:1001:likes 2001
(integer) 0
SISMEMBER post:1001:likes 2001
(integer) 1
SCARD post:1001:likes
(integer) 3
SINTER user:1001:follow user:1002:follow
1) "2003"
2) "2005"

SADD 返回 0 说明这个成员本来就在集合里。这一条返回值就能做「首次点赞才加计数」的幂等判断,不用先查再写。SINTER 求共同关注,SUNION 求并集,SDIFF 求差集,社交产品里的大部分关系计算都能用这三条拼出来。

代价是集合运算的复杂度跟元素数量有关。两个百万元素的 Set 做交集,可能阻塞几百毫秒,而 Redis 命令执行是单线程的,这期间所有请求排队。Redis 7 提供了 SINTERCARD 带 LIMIT,只数个数、可以提前停,比把结果全算出来安全。

ZSet:唯一自带排序的结构

ZSet 的每个成员都带一个分数,成员按分数排序,分数可以重复。插入、删除、按分数查都是 O(log N),按排名取一段是 O(log N + M)。排行榜、延迟队列、带权重的推荐候选,都靠它。

ZADD hot:20261106 100 product:1 88 product:2 30 product:3
(integer) 3
ZREVRANGE hot:20261106 0 2 WITHSCORES
1) "product:1"
2) "100"
3) "product:2"
4) "88"
5) "product:3"
6) "30"
ZINCRBY hot:20261106 5 product:2
"93"
ZSCORE hot:20261106 product:2
"93"
ZREVRANK hot:20261106 product:2
(integer) 1
ZRANGEBYSCORE hot:20261106 50 100
1) "product:2"
2) "product:1"

ZREVRANGE 按分数从高到低取,WITHSCORES 把分数一起带回来,榜单页一次请求就够。ZINCRBY 加分是原子的,成交一笔加一笔,不需要读改写。ZREVRANK 返回从 0 开始的名次,做「我的排名」很方便。

两个容易踩的点。第一,ZSet 会一直涨,榜单只展示前 100,但如果你不裁剪,一年下来成员可能有几十万。用 ZREMRANGEBYRANK 定期删掉尾部,或者给整个 key 设过期。第二,分数是浮点数,用时间戳当分数做延迟队列时,同一毫秒的多条消息顺序不稳定,需要自己加一个序列号拼进成员名。

和 Hash 一样,ZSet 也有编码切换:元素少时用 listpack,元素多了转成「字典加跳表」。字典负责 O(1) 查分数,跳表负责按分数范围扫描。常见阈值是 128 个元素、单个成员 64 字节,待确认,用 CONFIG GET zset-max-listpack-entries 查。所以「一万个成员的 ZSet 加一条要多久」和「一百个成员的 ZSet 加一条要多久」,答案不一样。

一次完整的场景走查:点赞、小时榜、购物车、锁

光看命令记不住。拿一个内容社区的真实需求走一遍,四个功能落在同一套 Redis 上,每个都标出数字和代价。

第一个,文章点赞。需要三样东西:这篇文章的总赞数、谁点过(防重复)、我点过的文章列表(按时间倒序)。做法是三个 key:post:{id}:stats 用 Hash 存 likes 和 views;post:{id}:likers 用 Set 存用户 id;user:{uid}:liked 用 ZSet 存文章 id,分数是时间戳。

一次点赞请求经过的四个步骤
SADD 判断是否已赞
HINCRBY 更新总赞数
ZADD 写入我的点赞列表
ZINCRBY 更新小时榜

这四步必须打包成一个原子操作,否则 SADD 成功、HINCRBY 失败,就会出现「显示已赞但总数没加」。用 Lua 脚本把四步串起来,Redis 执行脚本期间不会插入别的命令,这是它替代事务的常用做法。

数字上要算一笔账。一篇爆款 50 万赞,likers 这个 Set 存 50 万个整数,按整数集合估算约 4MB,元素超过阈值转成哈希表后接近 10MB。一千篇这样的文章就是 10GB。所以「谁点过」要么只保留最近一段,要么落库,Redis 里只留计数和布隆过滤器做判重。

第二个,小时榜。key 名带上小时,比如 rank:hour:2026110614,每次点赞 ZINCRBY 加一,给这个 key 设 25 小时过期。查当前榜时把当前小时和前一小时合并,用 ZUNIONSTORE,权重各为 1,或者给前一小时一个衰减权重。日榜由后台任务把 24 个小时榜合并一次,不要每次查询都合。

坑在小时边界:14:59 的赞记在 14 点的 key,15:00 的查询如果只读 15 点的 key,榜会突然清零。解法是查询时总把上一个小时的 key 一起读,或者延迟五分钟再结算。这个问题和数据库的「跨分区统计」是同一类,只是换了个地方发生。

第三个,购物车。一个用户一个 Hash,key 是 cart:{uid},字段是商品 id,值是数量。HSET 加商品,HINCRBY 改数量,HGETALL 一次拿全,HDEL 删除。改一个商品不影响其他商品,这是 Hash 相对 String 存整份 JSON 的最大好处。

但它不能按价格排序,也不能分页,HSCAN 只能按游标遍历。所以购物车列表页通常还是要回源商品服务补价格、库存和失效状态。Redis 在这里是「用户的选择」,不是「商品的真相」。

第四个,分布式锁。多个实例抢同一个订单的处理权。加锁是一条命令:

SET lock:order:123 <uuid> NX PX 30000
OK

NX 表示 key 不存在才设置,PX 30000 表示 30 秒后自动过期。拿到返回 OK 就是抢到了,返回 nil 就是没抢到。释放不能直接 DEL,要先比对 value 再删,否则会删掉别人的锁:

EVAL "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end" 1 lock:order:123 <uuid>
(integer) 1

这段 Lua 的意思是:只有锁里的值还是我写进去的那个 uuid,才删除。为什么要这么麻烦?假设 A 拿到锁,业务卡了 35 秒,锁在 30 秒时自动过期,B 抢到了锁。A 醒来后执行 DEL,删掉的是 B 的锁,C 又能进来,同一时刻就有两个人持锁。

锁还有三个坑,都是真实会出事的。第一,业务执行时间超过锁的过期时间,互斥就失效了,要么把超时设得比 P99 大很多,要么起一个后台线程定期续期,这就是常说的 watchdog。第二,不可重入,同一线程再调一次加锁会失败,需要重入就得用 Hash 记线程 id 和重入次数,或者用现成的客户端库。第三,主从切换会丢锁:写主节点成功但还没同步,主节点宕机,从节点升主,锁就没了。所以 Redis 锁是「大概率互斥」,不是强互斥;账务这种绝不允许并发的场景,用数据库唯一约束或专门的协调服务更稳。

不要自己实现「先 GET 判断,再 DEL」的释放逻辑,这两步之间会有竞态。也不要用 SETNX 加单独的 EXPIRE,两条命令之间进程崩了就是一把永远不释放的死锁。用 SET ... NX PX 一条命令写完。

上线后的结果与代价。四个功能上线后,读接口 P99 从 1.2 秒降到 20 毫秒,数据库 CPU 从 92% 回到 30%,代价是 Redis 常驻内存约 18GB、多了一条「数据库变更同步到 Redis」的链路,以及一套处理锁超时和热点 key 的告警。最麻烦的不是命令怎么写,而是「Redis 里的数和库里的数不一致时,以谁为准」这个约定,必须在编码前就定下来。

过期与淘汰:内存不会自己让出来

给 key 设了过期时间,不代表到点内存立刻释放。Redis 用的是两种策略配合:惰性删除和定期抽样。

惰性删除是「访问到这个 key 时才发现过期,顺手删掉」。如果一个 key 再也没人访问,它就会一直占着内存。定期抽样是后台每 100 毫秒随机取一批 key 检查,过期比例超过四分之一就继续取,直到比例降下来或者达到时间上限。所以一个过期的大 key,可能要过一阵才真正消失。

当内存达到 maxmemory,Redis 开始按策略淘汰 key。常用策略有:allkeys-lru 从所有 key 里淘汰最久没用的,allkeys-lfu 淘汰访问频率最低的,volatile-lru 只淘汰设了过期时间的,volatile-ttl 优先淘汰快要过期的,noeviction 不淘汰、直接对写入报错。

纯缓存场景用 allkeys-lru,热点明显且访问频率差异大时用 allkeys-lfu 更稳。把 Redis 当数据库用、一条都不能丢,才用 noeviction,但要接受写满之后写入全部失败。注意 LRU 是近似的:每次只抽样几个 key 比较,maxmemory-samples 默认 5,不是精确的全局排序。抽样越多越准,CPU 也越高。

还有一个常见误判:内存涨了但 key 数量没涨。先看 INFO memory 里的 mem_fragmentation_ratio,大于 1.5 说明碎片多;再看有没有大 key 过期了还没被删;最后才怀疑泄漏。

现象、原因与第一步排查

缓存用起来之后,故障基本集中在下面这几类。表里的「第一步」都是在不改代码的前提下能做的动作。

现象真实原因第一步查什么
查不存在的 id,每次请求都打到数据库缓存穿透,空结果没有缓存,恶意 id 绕过了缓存看 INFO stats 的命中率,抽几个不存在的 id 看是否直接落到库
半夜整批接口同时变慢缓存雪崩,大量 key 的过期时间被设成同一个值用 SCAN 抽样看 TTL 分布,确认过期时间有没有加随机偏移
单个热点 key 过期瞬间数据库飙升缓存击穿,重建期间并发请求全部回源看监控里该 key 的 miss 是否集中在同一秒,确认有没有互斥重建
一次 HGETALL 让整个实例卡住大 key,单个 Hash 或 Set 有几十万个元素跑 redis-cli --bigkeys,再用 MEMORY USAGE 看具体大小
某个 key 的 QPS 远高于其他 key热 key,爆款商品或明星数据集中在一个分片看 INFO commandstats 和热点 key 监控,必要时本地缓存或拆 key
列表页是新数据,详情页是旧数据双写不一致,更新顺序错、并发回填旧值、删除缓存失败查更新代码是先删缓存还是后删,再看删除失败有没有重试和日志
内存一直涨,key 数量却稳定内存碎片、大 key 过期未删、或者 value 本身在变大INFO memory 看碎片率,MEMORY DOCTOR 看诊断建议
写操作报 OOM 错误达到 maxmemory 且策略是 noeviction,或没有可淘汰的 keyCONFIG GET maxmemory 和 maxmemory-policy,再看 evicted_keys 是否长期为 0

边界与代价

第一,内存贵。同样一 TB 数据,放内存的成本远高于放 SSD 上的数据库。Redis 的定位是「热数据」,不是「全部数据」。把全量历史订单塞进去,账单会先撑不住。

第二,单线程怕慢命令。一次 KEYS *、一次大 Hash 的 HGETALL、一次百万元素的 SINTER、一次大 key 的 DEL,都会让所有请求排队。换成 SCAN、HSCAN、SINTERCARD、UNLINK,把一次大操作拆成多次小操作。

第三,集群下多 key 操作受限。事务、Lua、SINTER、MGET 都要求涉及的 key 在同一个 slot。要么用 hash tag 把相关 key 绑在一起,要么在客户端拆开多次请求。绑在一起又会带来热点,两个问题要一起权衡。

第四,持久化不等于备份。RDB 是快照,AOF 是命令日志,都可能丢一段;误删的 key 也会被写进 AOF,跟着一起丢。真正的备份要定时把文件拷到别的机器,并定期做恢复演练。

第五,它不是数据库。没有 JOIN,没有二级索引,没有强事务,MULTI 只是把命令打包顺序执行,中途出错不会回滚。拿 Redis 当主存储,最后都要在应用层补一套数据恢复和对账。

第六,扩容和运维有额外成本。集群要规划分片、处理 reshard、监控主从延迟;单机要处理内存碎片、fork 阻塞和主从切换。这些在下一篇讲原理时会展开,因为它们决定了「快」能不能稳住。

当天可以自己验证的练习

  1. 用容器起一个本地 Redis,连上去依次执行 PING、SET、GET、INCR、EXPIRE,每隔几秒看一眼 TTL,确认它是递减到 -2 而不是直接变 0。
  2. 用 LPUSH 和 BRPOP 造一个十条消息的队列,开两个终端同时 BRPOP,观察两个消费者怎么抢。
  3. 用 ZADD 造一个 100 人的榜单,取前 10,再用 ZREMRANGEBYRANK 裁掉 50 名之后,用 ZCARD 验证数量。
  4. 写一个 SET ... NX PX 的锁,故意让业务 sleep 超过锁时间,在另一个终端抢锁,然后用 Lua 释放,观察返回值是 0 还是 1。
  5. 设一个较小的 maxmemory 并选 allkeys-lru,持续写入直到开始淘汰,用 INFO stats 看 evicted_keys 的增长。

小结

Redis 的五种结构,本质是五种不同的取值顺序:String 按 key 取整块,Hash 按字段取,List 按插入位置取,Set 按成员判断在不在,ZSet 按分数排好序。选结构就是选你以后要按什么方式读,选错了会在数据量上来之后以「某条命令突然变慢」的形式还给你。

缓存的三件事必须同时想:穿透、雪崩、击穿,分别对应「不存在的 key」「同时过期」「热点重建」。再往上,大 key 和热 key 是容量和分布问题,双写不一致是一致性问题。这五类问题不解决,缓存只是把故障从数据库挪到了缓存层。

会用之后,下一个问题自然会冒出来:它凭什么快,持久化到底能保住多少数据。下一篇讲Redis 为什么快:内存、单线程与持久化,从一次「重启后回退一秒」的排查开始,把单线程、IO 多路复用、RDB 和 AOF 这几件事一次说清楚。