Redis（内存数据存储）数据类型与单线程模型

热身 · 一 Redis（内存数据存储）放在哪里 · 二 字符串 · 三 过期 · 四 哈希 · 五 列表与集合 · 六 有序集合 · 七 单线程与慢命令 · 八 应用 · 检验 · 表达 · 追问 · 隔日复测

本课要解决什么问题

学完本课，给你一个业务需求，例如“验证码5分钟有效”“经办人当天三项计数”“每个人最近看过的10件办件”“找出已过期限的办件”，你能选出合适的Redis（内存数据存储）数据类型，写出关键命令和对应的Java调用，并说清要不要设过期时间、怎样设才不会失效。你还能解释Redis（内存数据存储）所说的“单线程”指什么，为什么生产环境不能随手执行 KEYS（列出所有匹配键的命令）。

关于Redis（内存数据存储），最常见的两个问题是：“Redis（内存数据存储）有哪些数据类型，各用在什么场景？”“Redis（内存数据存储）为什么快？单线程为什么还快？”本课先把数据类型和线程模型打牢；持久化、缓存穿透／击穿／雪崩、缓存与数据库一致性放在后面几课。

版本： 截至2026年10月，Redis（内存数据存储） Open Source最新版本是8.10.2（2026-09-17发布）。本课命令在6.2及以后的版本都适用；只在7.4及以后才有的功能会单独标出。Redis（内存数据存储） 8起的许可证为三选一（RSALv2、SSPLv1、AGPLv3）；7.4至7.8是RSALv2／SSPLv1双许可；7.2及更早仍是BSD3。所以一些资料里“Redis（内存数据存储）是BSD许可”的说法已经过时。[13]

前置： 第3课的原子性（多线程 count++ 为什么会少加）；第6课的 HashMap（普通哈希映射）。 必学： 第一至八节、六道选择题和四问表达。第四节后可暂停。内部编码、I/O线程配置放在折叠拓展里。本课的命令和Java代码都按官方文档核对，没有实际运行Redis（内存数据存储）实测。

主读： 官方 Redis（内存数据存储） data types（数据类型总览）。先读页面上Strings、Hashes、Lists、Sets、Sorted sets五段的定义，再点进各类型页面看“Basic commands”。其他类型（JSON、Streams等）本课不要求。本课引用的官方页面都列在文末“官方来源”。

热身：先把第15课的三个要点说一遍

先凭记忆回答，再展开核对。答不上来就记一句，接着往下学，这不是进入新课的门槛。

一、Redis（内存数据存储）放在系统的哪里，存的是什么

“Redis（内存数据存储）是什么？和MySQL是什么关系？”

先看一个办件系统的典型请求：经办人打开20号办件的详情页。没有Redis（内存数据存储）时，每次打开都要查MySQL（关系型数据库）。详情页被反复打开、内容又不常变，就可以把查出来的结果放进Redis（内存数据存储），下次先查Redis（内存数据存储），查到了就不用再访问MySQL（关系型数据库）。

官方对Redis（内存数据存储）的定位是“内存中的数据结构存储”（in-memory data structure store），名字来自Remote Dictionary Server。它和普通键值存储的区别是：每个 key（键）对应的 value（值）不只是一个字符串，还可以是哈希、列表、集合等数据类型，而且在这些类型上定义了原子操作。数据放在内存里，读写非常快，代价是数据集不能大于内存。官方同时说明它也能持久化到磁盘，持久化放在下一课。[1]

官方当前列出的类型很多，包括JSON、Streams、向量集合等；日常业务最常用、也最常被问到的是下面五种。[11]图1把它们和办件系统的例子放在一起：

键名约定： 本课用“业务:对象:编号”的格式命名键，例如 case:detail:20 表示“办件详情、20号”。这是常见的团队约定，便于按前缀管理，不是Redis（内存数据存储）的强制规则。

二、String（字符串类型）：缓存、验证码、计数

“String（字符串类型）一般用来做什么？”

官方说明：Redis（内存数据存储）的字符串存的是字节序列，可以是文本、序列化后的对象或二进制数据，单个值最大512 MB。它最常用来做缓存，也支持计数。[2] 办件系统里有三种典型用法：

# 1. 缓存20号办件详情（序列化成JSON），10分钟后过期
SET case:detail:20 '{"id":20,"status":"已通过"}' EX 600
GET case:detail:20

# 2. 存验证码本身，5分钟后失效
SET sms:code:13800000000 482913 EX 300
#    发送前先限制：60秒内只能发一次
SET sms:limit:13800000000 1 NX EX 60

# 3. 今天的受理量加1
INCR stat:accept:2026-10-09

验证思路：命令和选项按官方SET、INCR命令页核对，本课没有实际运行。有测试实例时，可以连续执行两次 SET sms:limit:… 这条命令：第一次返回OK，60秒内第二次不返回OK（键已存在，没有设置成功）。

SET的两个选项： EX 600 表示设置600秒后过期；NX 表示“只有这个键不存在时才设置”。验证码本身用 EX 300 存5分钟，用户提交时 GET 出来比对，过期后就读不到了。限发那条命令里，第一次执行时键不存在，设置成功，应用就去发短信；60秒内再执行，键还在，设置不成功，应用就提示“请稍后再试”。60秒后键自动删除，又可以发了。[2]

官方SET页面也提到，SET 资源名 任意值 NX EX 秒数 是实现锁的一种简单写法，但官方不推荐这种写法，建议用Redlock算法。分布式锁是另一个需要单独学习的主题，本课的NX只用来做“不重复发送”。[2]

INCR为什么不会少加

热身里说过，Java的 count++ 是“读、加、写”三步，两个线程可能都读到10，最后写回11。Redis（内存数据存储）的 INCR 不会这样。官方专门解释了“INCR是原子的”是什么意思：多个客户端同时对同一个键执行INCR，不会出现客户端1读到10、客户端2也读到10、两边都写回11的情况，最终一定是12。因为“读、加、写”这一整步执行时，其他客户端的命令都不在同时执行。键不存在时，INCR先把它当成0再加1。[2]

所以多台应用服务器同时统计受理量，用INCR不需要应用自己加锁。为什么Redis（内存数据存储）能做到“执行时其他命令都不在执行”，第七节讲单线程时会接上。

三、过期时间：设了以后，哪些操作会把它弄丢

“Redis（内存数据存储）的过期时间怎么设？过期的键是到点立刻删除的吗？”

缓存和验证码都应该带过期时间。除了SET的EX选项，还可以对已有的键执行 EXPIRE 键 秒数。官方说明：过期时间到了，键会被自动删除（到期后就读不到，具体何时从内存清掉见本节末尾）。TTL 键 查看剩余秒数：返回 −2 表示键不存在，返回 −1 表示键存在但没有过期时间。[3]

最容易踩的坑：重新SET会清掉旧的过期时间。 官方说明，只有删除或覆盖键内容的命令（DEL、SET、GETSET等）才会清除过期时间；只是修改内容、不整个替换的操作会保留原来的过期时间，官方举的例子是对计数器INCR、用LPUSH往列表里追加、用HSET改哈希的某个字段。SET页面也写明：SET成功后，键原来的过期时间会被丢弃。[3] [2]

所以写缓存时， 每一次 SET都要带上过期时间；Java里每次调用都要传 Duration（见第五节末尾的代码）。Redis（内存数据存储） 6.0起SET还有一个 KEEPTTL 选项，覆盖值时保留原来的过期时间。[15]

计数器怎样设过期：看INCR的返回值

第二节的每日受理量 stat:accept:2026-10-09 也需要过期，否则每天留下一个永久的键。可是这个键是INCR第一次执行时自动创建的，没有机会在SET时带EX。官方INCR页面给的做法是 看INCR的返回值 ：

INCR stat:accept:2026-10-09
# 如果上面返回的是1，说明这个键刚刚被创建，再给它设过期（两天后清理）
EXPIRE stat:accept:2026-10-09 172800

验证思路：做法来自官方INCR页面的限流示例（INCR返回1时再EXPIRE），本课没有实际运行。有测试实例时，INCR后执行TTL（剩余存活时间）应约为172800；再INCR一次，TTL（剩余存活时间）继续倒数，不会重新回到172800。

之后每次INCR，返回值都大于1，不再执行EXPIRE；INCR只修改内容，也不会清掉已经设好的过期时间，所以倒计时一直从第一次开始算。 注意一个边界： INCR和EXPIRE是两条命令，如果应用执行完INCR、还没来得及执行EXPIRE就崩溃了，这个键就没有过期时间，会一直留下来。官方指出了这个竞态，并给出修法：把“INCR，返回1时再EXPIRE”写成一段Lua脚本，作为一条命令发给Redis（内存数据存储）执行。Lua脚本本课不展开。[15]

过期的键是不是到点立刻删除？ 不一定。官方说明过期有两种方式：被动方式是客户端访问一个已经过期的键时，Redis（内存数据存储）发现它过期了就删除；主动方式是Redis（内存数据存储）定期从设置了过期时间的键里随机抽查一些，删除其中已过期的。[3] 对应用来说，过期的键读不到；但它在被删除前可能还占着一点内存。

四、Hash（哈希）：一个对象的多个字段

“存一个对象，用String（字符串类型）存JSON还是用Hash（哈希）？”

官方说明：Redis（内存数据存储）的哈希是“字段—值”对的集合，类似Java的HashMap（普通哈希映射），可以用来表示对象，或者把一组计数器放在一起。[4] 例如每个经办人当天要统计受理、办结、退回三项数字：

# 7号经办人受理了一件：accepted 字段加1
HINCRBY stat:staff:7:2026-10-09 accepted 1
# 只读一个字段
HGET stat:staff:7:2026-10-09 accepted
# 一次读三个字段
HMGET stat:staff:7:2026-10-09 accepted finished returned

验证思路：命令按官方Hash（哈希）页面核对，本课没有实际运行。有测试实例时，执行两次第一条命令后，HGET应返回2。

用Hash（哈希）的好处是能 只改一个字段 ：受理一件就只给accepted加1，不用把整个对象读出来、改完再写回去。如果换成String（字符串类型）存一段JSON，每次加1都要“读出整段 → 应用里改 → 整段写回”，和热身里的count++一样有并发覆盖的风险。

这张取舍表参考了JavaGuide的说法：多数情况下String（字符串类型）更合适，经常修改部分字段时选Hash（哈希）。[14]

注意 HGETALL： 官方说明大多数哈希命令是O(1)，但HGETALL、HKEYS、HVALS是O(n)，n是字段数。字段很多时一次取全部会很慢，第七节会讲为什么“慢一条”会拖住所有请求。[4]

这里可以暂停。先能说清String（字符串类型）和Hash（哈希）各适合什么、过期时间怎样才不会丢，再继续看后三种类型。

五、List（列表）与 Set（集合）：要顺序，还是要不重复

“List（列表）和Set（集合）有什么区别？各举一个场景。”

List（列表）：按放入顺序排，适合“最近N条”

官方说明：Redis（内存数据存储）的列表是按插入顺序排列的字符串链表。因为是链表，即使有几百万个元素，往头部或尾部加一个元素也是常数时间；代价是按下标访问中间的元素会慢，要走的步数和下标成正比。[5]

例如“7号经办人最近看过的10件办件”。每打开一件，就把编号从左边放进去，然后只保留前10个：

LPUSH recent:staff:7 20      # 从左端（头部）放入20号
LTRIM recent:staff:7 0 9     # 只保留下标0到9，也就是最新的10个
LRANGE recent:staff:7 0 9    # 读出这10个，最新的在前

验证思路：命令按官方List（列表）页面核对，本课没有实际运行。有测试实例时，连续LPUSH 12个不同编号再执行LTRIM，LRANGE应只返回最后放入的10个。

官方把 LPUSH＋LTRIM 称为“只记住最新N条、丢掉旧的”的用法。[5] 同一个人重复打开20号会放进两次，如果要去重，需要先从列表里删掉旧的再放入，这里不展开。

官方也介绍了用列表做简单队列：生产者LPUSH，消费者用BRPOP阻塞等待新元素，不必轮询。[5] 业务上需要“消息不丢、能重试”的可靠队列时，应考虑专门的消息队列，本课不把List（列表）当成可靠消息队列。

Set（集合）：成员不重复，适合去重和关系

官方说明：集合是不重复字符串的无序集合，可以用来记录唯一项（例如访问过某篇文章的不重复IP）、表示关系（例如拥有某个角色的所有用户），以及求交集、并集、差集。添加、删除、判断成员都是O(1)。[6]

SADD case:readers:20 7        # 7号经办人看过20号办件（重复执行不会重复记录）
SISMEMBER case:readers:20 7   # 7号看过吗？返回1表示是
SCARD case:readers:20         # 有多少人看过
SINTER role:approver role:legal   # 同时在两个集合里的成员（交集）

验证思路：命令按官方Set（集合）页面核对，本课没有实际运行。有测试实例时，对同一成员执行两次SADD，SCARD仍应返回1；两个集合各放几个成员后，SINTER只返回两边都有的。Java对应 opsForSet().intersect(键1, 键2)。

注意 SMEMBERS： 它一次返回整个集合，是O(n)。官方提醒，几十万成员以上的大集合要小心使用，可以改用SSCAN分批取。[6]

在Java里怎么写

Spring Data Redis（Spring 的内存数据存储访问模块）的 RedisTemplate 按Redis（内存数据存储）命令的分组提供操作入口：opsForValue() 对应字符串，opsForHash()、opsForList()、opsForSet()、opsForZSet() 分别对应哈希、列表、集合、有序集合。StringRedisTemplate 把键和值都按字符串保存，在命令行里能直接看懂。[12]

// stringRedisTemplate 由 Spring Boot 注入
ValueOperations<String, String> value = stringRedisTemplate.opsForValue();
value.set("case:detail:20", json, Duration.ofMinutes(10));          // SET … EX 600
Boolean canSend = value.setIfAbsent("sms:limit:13800000000", "1",
        Duration.ofSeconds(60));                                     // SET … NX EX 60
Long accepted = value.increment("stat:accept:2026-10-09");          // INCR

stringRedisTemplate.opsForHash()
        .increment("stat:staff:7:2026-10-09", "accepted", 1);       // HINCRBY

ListOperations<String, String> recent = stringRedisTemplate.opsForList();
recent.leftPush("recent:staff:7", "20");                            // LPUSH
recent.trim("recent:staff:7", 0, 9);                                // LTRIM
List<String> latest = recent.range("recent:staff:7", 0, 9);         // LRANGE

stringRedisTemplate.opsForSet().add("case:readers:20", "7");        // SADD
Boolean read = stringRedisTemplate.opsForSet().isMember("case:readers:20", "7"); // SISMEMBER

验证思路：方法名和参数按Spring Data Redis（Spring 的内存数据存储访问模块）当前Javadoc核对（见来源[12]），本课没有编译运行。setIfAbsent 返回true表示设置成功、可以发短信；注意 value.set(...) 这一行每次都传了 Duration，避免第三节的过期时间丢失问题。

六、Sorted Set（有序集合）：按分数排好，适合排行和到期

“排行榜用什么类型？有序集合底层是什么结构？”

官方说明：有序集合是不重复成员的集合，每个成员带一个分数（score），按分数排序；分数相同时按成员的字典序排。典型用途有排行榜和限流。[7]

办件系统里有一个很合适的场景： 找出已经超过办理期限的办件。 把办件编号作为成员、办理期限的时间戳作为分数放进去，定时任务每分钟只需对Redis（内存数据存储）按分数取一次“期限 ≤ 现在”的那一段，不用去扫办件表：

# 20号办件的期限是北京时间 2026-10-09 09:00，秒级时间戳 1791507600 作为分数
ZADD case:deadline 1791507600 20
# 假设现在是北京时间 10-09 16:00（1791532800）；0 表示从最小分数开始
ZRANGE case:deadline 0 1791532800 BYSCORE
# 办理完成后从集合里移除
ZREM case:deadline 20

验证思路：ZADD、ZRANGE的BYSCORE参数按官方页面核对；时间戳是示意数值，实际用 Instant.now().getEpochSecond() 之类的方法计算。本课没有实际运行。

排行榜 同理：成员是经办人编号，分数是本月办结数。ZRANGE rank:finish:2026-10 0 9 REV 按分数从高到低取前10名。官方说明，从Redis（内存数据存储） 6.2起，ZRANGE加上BYSCORE、REV等参数可以替代ZRANGEBYSCORE、ZREVRANGE等旧命令，ZRANGEBYSCORE已被标为弃用；旧资料里还常见旧命令，认识即可。[7]

底层结构： 这是常见追问。官方的实现说明是：有序集合由 一个skip list（跳表）和一个哈希表 两部分组成，所以每次添加元素是O(log N)的操作。[7] 可以这样理解两部分的分工：哈希表让“按成员找分数”很快，跳表让成员始终按分数排好、能快速取一段范围。这一句分工是对官方说明的理解，官方原文只说由这两部分组成。跳表的具体结构本课不展开。

分数会变怎么办： 对已经存在的成员再执行一次ZADD，会更新它的分数；只想在原分数上加一点（例如办结数加1），用 ZINCRBY 键 增量 成员。[12] [15]

Java里对应 opsForZSet().add(键, 成员, 分数)、rangeByScore(键, 最小分, 最大分)、reverseRange(键, 0, 9)（按分数从高到低取前10）。[12]

七、“单线程”到底指什么，为什么一条慢命令会拖住所有人

“Redis（内存数据存储）是单线程的吗？单线程为什么还这么快？”

官方的原话是“mostly single threaded”（基本是单线程的）：一个进程服务所有客户端的请求， 同一时刻只处理一个请求，所有请求按顺序执行 。一个线程怎么照看成百上千个连接？它同时盯着所有连接，哪个连接的数据到了就处理哪个，这种做法叫I/O多路复用。说“基本”，是因为Redis（内存数据存储）也会用后台线程做一些慢的磁盘I/O等工作，但这不改变“所有请求由一个线程处理”这件事。[8]

为什么还快？ 官方给的理由有两条：一是单个请求本身完成得很快；二是更主要的原因，某个连接的数据还没到时，Redis（内存数据存储）不会停下来等它，而是先去处理别的连接，不会卡在读写网络这类系统调用上。官方FAQ还说，Redis（内存数据存储）的瓶颈通常是内存或网络，很少是CPU（处理器）。[8] 再加上数据都在内存里，一次GET、SET通常只花很短的时间。

一些学习资料（例如JavaGuide）常补一句“单线程执行命令，避免了多线程的锁竞争和上下文切换”。这是常见的解释，但本课在官方页面里没有找到这句原话，回答时可以作为自己的理解来说。[14] 第二节INCR“执行时其他命令不同时执行”，正是“请求按顺序一个个执行”带来的效果。

代价：一条慢命令，所有人一起等

官方把后果说得很直接：因为是单线程，一个请求处理得慢，其他所有客户端都要等它处理完。GET、SET、LPUSH这类常数时间的命令没问题；但有些命令要处理很多元素，比如SORT、SUNION等。[8] 最典型的是 KEYS：官方明确要求在生产环境极其小心，它在大数据库上执行可能拖垮性能，只用于调试；需要按前缀找键时，用SCAN，或者写入键时把键名SADD到一个集合里，需要时读这个集合。[9] 注意：KEYS的复杂度是O(N)，N是 整个库 的键数；KEYS case:detail:* 虽然带了前缀，仍要把几百万个键逐个拿来比对，匹配到的键少，耗时也不会少。[15]

SCAN是基于游标的迭代器：从游标0开始，每次调用返回一小批元素和下一个游标，服务器返回的游标为0时遍历结束。官方说明它每次只返回少量元素，所以可以在生产环境使用，不会像KEYS、SMEMBERS那样在大集合上阻塞服务器很久（甚至几秒）。代价是同一个元素可能返回多次，应用要能处理重复。还有两点容易用错：某一批返回空列表不代表结束，要一直调用到返回的游标为0；SCAN的总工作量并没有变少，只是拆成很多小批执行，不会长时间挡住别人。[9] [15] 集合、哈希、有序集合也有同一系列的SSCAN、HSCAN、ZSCAN。

由此得到两条习惯： 生产代码里不用KEYS；对成员很多的集合或哈希，不一次取全部（SMEMBERS、HGETALL），改用对应的SCAN系列分批取。

八、应用：为新需求选结构，排查一次线上问题

“给你几个业务需求，你会怎么用Redis（内存数据存储）实现？”

A．为三个新需求选结构

背景： 办件系统新增三个需求。请为每个需求选择Redis（内存数据存储）数据类型，写出关键命令，并说明过期时间怎么处理。正文演示过的是验证码、每日受理量、最近浏览、已阅名单，这三个需求要你迁移。

1. 登录失败锁定： 同一个账号从第一次输错密码开始计时，5分钟内累计输错5次就锁定。锁定一直持续到这个5分钟窗口结束、计数自动清零为止。每次登录前，系统先读计数，达到5就直接拒绝，不再校验密码。要求：后面的错误 不能 把5分钟窗口往后延长。
2. 部门首页滚动展示： 每个部门首页滚动显示本部门 最近提交 的50件办件编号，新的在前。
3. 会签人员： 某类办件需要“既有审批角色、又有法制审核角色”的人员会签。系统里已经分别维护了“审批角色成员”和“法制审核角色成员”两份名单，要算出同时在两份名单里的人。

B．一次线上问题：接口都变慢，内存还在涨

背景： 线上Redis（内存数据存储）里有几百万个键。运维同事写了一个定时任务，每分钟执行一次 KEYS case:detail:*，统计当前缓存了多少件办件详情。另外，办件详情缓存最初都用 set(键, json, Duration.ofMinutes(10)) 写入，带10分钟过期。后来有两段刷新代码会改这些缓存：

// 刷新代码A：办件被修改后，重写整段详情
stringRedisTemplate.opsForValue().set("case:detail:" + id, json);

// 刷新代码B：办件被浏览后，给统计哈希里的一个字段加1（统计哈希也带了过期时间）
stringRedisTemplate.opsForHash().increment("case:stat:" + id, "views", 1);

验证思路：这是练习题给定的代码，请先自己判断，再展开核对。

观察到的现象： 每分钟都有一小段时间，所有接口访问Redis（内存数据存储）都变慢；同时Redis（内存数据存储）内存持续增长，几天也降不下来，很多键的TTL（剩余存活时间）是 −1。

1. 为什么一个统计任务会让 所有 接口都变慢？“只匹配 case:detail: 开头的键”能不能让它变快？应该怎样改这个统计？
2. 刷新代码A和B，哪一段会让键的TTL（剩余存活时间）变成 −1？为什么另一段不会？应该怎样改？

九、即时检验：先判断，再读解释

每题只问一个主要判断。先作答，再展开核对答案与解释。

1. 选结构

每个经办人当天有受理、办结、退回三个数字。每发生一笔业务，只有其中一个数字加1；页面偶尔要同时显示三个数字。

问题： 选哪种存法最合适？

• A. 用String存JSON
• B. 用Hash存三个计数字段
• C. 用List按顺序存三个数

2. 重新SET以后

一个键先用 SET 键 值 EX 600 写入。2分钟后，另一段代码执行 SET 键 新值，没有带EX。紧接着执行 TTL 键。

问题： TTL（剩余存活时间）返回什么？

• A. 负一，键不会再过期
• B. 负二，键已经不存在
• C. 大约还剩四百八十秒

3. 同时计数

键 stat:accept 当前值是10。两台应用服务器几乎同时各执行一次 INCR stat:accept，都执行成功。

问题： 最终的值是多少？

• A. 一定是十二
• B. 可能是十一
• C. 一台会报错

4. 生产上执行KEYS

线上Redis（内存数据存储）有几百万个键。有人在业务高峰执行 KEYS case:*，这条命令要执行一段时间。

问题： 在它执行期间，其他客户端的GET会怎样？

• A. 由其他线程并行执行
• B. 直接返回空值不等待
• C. 排队等这条命令结束

5. 找出已超期的办件

有序集合 case:deadline 的成员是办件编号，分数是办理期限的时间戳。

问题： 要找出期限不晚于当前时间的办件，应该怎样查？

• A. 按成员名字的顺序取
• B. 按分数范围取出一段
• C. 按插入先后的顺序取

6. “单线程”指什么

常见问题：“都说Redis（内存数据存储）是单线程的，那它进程里是不是只有一个线程？”

问题： 哪种说法最准确？

• A. 命令由一个线程按顺序执行
• B. 整个进程始终只有一个线程
• C. 每个客户端分配单独的线程

十、把过程讲出来：用完整回答检验理解

连续回答下面四问，可以写下来，也可以先口述再整理成文字。每问先说是什么，再说为什么，最好带一个办件系统的例子。写完再对照各节的参考回答。

第一问：五种常用数据类型

请介绍Redis（内存数据存储）常用的数据类型。

请回答： String（字符串类型）、Hash（哈希）、List（列表）、Set（集合）、Sorted Set（有序集合）各是什么样的结构？各举一个办件系统里的场景和一条关键命令。存一个对象时，String（字符串类型）和Hash（哈希）怎么选？

第二问：单线程为什么还快

常见问题：“Redis（内存数据存储）是单线程的吗？为什么还这么快？有什么代价？”

请回答： “单线程”具体指什么？快的原因有哪些？为什么一条慢命令会影响所有客户端？6.0以后的多线程做的是什么？

第三问：过期时间

你负责办件详情缓存，要求10分钟后过期。

请回答： 怎样设置过期时间？TTL（剩余存活时间）返回−1和−2各表示什么？哪些操作会让过期时间丢失，举一个会因此出问题的代码写法。过期的键是到点立刻删除的吗？

第四问：生产上遍历键

运维需要统计所有以 case:detail: 开头的键有多少个，线上有几百万个键。

请回答： 为什么不能用KEYS？应该用什么，它是怎么工作的，有什么要注意的？对一个有几十万成员的集合，又该怎样取全部成员？

练习：请在自己的笔记中写出答案（可附第八节的判断过程），再对照各节参考回答核对。

十一、集中追问：把容易混的地方分开

先自己解释，再展开核对

十二、隔日复测：换一个业务对象

隔一天再用五分钟回答；约一周后再换场景试一次。刚学完马上复述，只能说明短时记忆。

官方来源与配套材料

本课速查 · 完整术语表。命令和代码按官方文档核对，没有实际运行Redis（内存数据存储）；时间戳、计数等数字为示意。

1. Redis（内存数据存储） FAQ与数据结构存储入门：内存数据结构存储、与普通键值存储的区别。

2. Strings、SET、INCR：用途、512 MB、NX／EX、覆盖丢弃过期时间、INCR原子性。

3. EXPIRE、TTL（剩余存活时间）：自动删除、清除过期时间的命令、被动与主动过期、−1／−2。

4. Hashes：字段—值对、HINCRBY、HGETALL为O(n)、7.4起字段过期。

5. Lists：链表、LPUSH／LTRIM保留最新N条、BRPOP。

6. Sets：唯一成员、关系、交并差、SMEMBERS与SSCAN。

7. Sorted sets、ZRANGE：按分数排序、跳表加哈希表、BYSCORE、ZRANGEBYSCORE弃用。

8. 延迟诊断、FAQ、redis.conf 8.10.2：基本单线程、慢命令阻塞、瓶颈在内存或网络、I/O线程。

9. KEYS、SCAN：生产警告、游标迭代、可能重复。

10. OBJECT ENCODING、内存优化：内部编码与阈值。

11. 数据类型总览：官方类型列表与五种基础类型定义。

12. Spring Data Redis（Spring 的内存数据存储访问模块）：RedisTemplate及各操作接口Javadoc：opsForValue等操作视图、StringRedisTemplate。

13. Redis（内存数据存储）许可证、8.10.2发布：Redis（内存数据存储） 8起三选一许可，7.2及更早为BSD3。

14. JavaGuide：Redis（内存数据存储）常见问题总结（上）（第三方）：类型场景、String（字符串类型）与Hash（哈希）存对象的取舍、单线程的常见解释。

15. INCR、EXPIRE、KEYS、SCAN、ZINCRBY、SET 命令页：INCR返回1时EXPIRE及其竞态与Lua修法、保留过期时间的例子、KEYS为O(N)、SCAN零元素不代表结束、ZINCRBY、KEEPTTL。

第15课 · 第18课

学完后，用办件系统的具体场景检查自己能否讲清“为什么重新SET会让缓存永不过期”“有序集合为什么要同时用跳表和哈希表”，而不只是背出“五种类型”。记下仍不确定的地方，隔日回看时先尝试回答，再核对课程里的解释。本课末尾的课后问答记录了几处容易说错的地方。

课后问答：理解是怎样变化的

问题与结论默认可见。展开后可看理解过程；以下根据真实交流整理，并非逐字稿。

存一个办件对象时，用String（字符串类型）存JSON还是用Hash（哈希）？

最终结论： 对象大多整体读、很少改，用String（字符串类型）存JSON；经常单独修改某几个字段（例如经办人的受理数、办结数），用Hash（哈希），例如 HINCRBY 键 字段 1。

Redis（内存数据存储）一个线程照看很多连接，某个连接的数据还没到时，它是排队等这个连接，还是先做别的？

最终结论： 不等，先处理别的连接。Redis（内存数据存储）快的原因可以这样串起来：①数据在内存里，单个GET、SET很短；②更主要的是用I/O多路复用照看连接，不会卡在网络读写上；③瓶颈通常是内存或网络，很少是CPU（处理器）。

为什么一条慢命令（例如KEYS）会让所有客户端都变慢？

最终结论： KEYS执行的这段时间里，其他客户端的GET、SET只能排在它后面等，这正是单线程的代价。6.0以后的I/O线程只处理网络读写和协议解析，命令仍由一个线程执行。

覆盖一个键的值、又想保留原来的过期时间，SET要加什么选项？

最终结论： 用 KEEPTTL（Redis（内存数据存储） 6.0起）：SET 键 新值 KEEPTTL，覆盖值的同时保留原来的过期时间。

举一个会让缓存过期时间丢失的代码写法，应该怎样改？

最终结论： 刷新缓存时调用 stringRedisTemplate.opsForValue().set(key, json)，没传 Duration，等于不带EX的SET：原来的10分钟过期被丢弃，TTL（剩余存活时间）变成 −1，缓存永不过期，内存只增不减。改法是每次写入都传 Duration.ofMinutes(10)，或用KEEPTTL保留原过期时间。

过期的键是怎么被删除的？是靠定期把所有键扫一遍吗？

最终结论： 两种方式：被动，客户端访问一个已过期的键时，Redis（内存数据存储）发现过期就删除；主动，定期从设置了过期时间的键里随机抽查一部分，删除其中已过期的。过期键可能在内存里多待一会儿，但对应用来说过期后就读不到了。

统计整个库里以 case:detail: 开头的键，和取一个几十万成员的集合，分别该用什么？

最终结论： 前缀统计用 SCAN 游标 MATCH case:detail:* COUNT 数量，不用KEYS；大集合用 SSCAN 集合键 游标，不用SMEMBERS。用法相同：从游标0开始，返回的游标为0才算结束，某一批返回空不代表结束；同一个元素可能返回多次，应用要能处理重复。

介绍Sorted Set（有序集合）时，应该先说什么？

最终结论： 先说它对外是什么：每个成员带一个分数，按分数排序，适合排行榜、按期限取任务（ZRANGE 键 0 现在时间戳 BYSCORE）；再说底层：官方说明由跳表和哈希表组成，添加是O(log N)。