面试题集锦:Redis 与缓存

通识对照:缓存三害:穿透、击穿、雪崩与 Cache Aside 边界

面试题集锦:Redis 与缓存

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:18 题
核心主题:分布式锁(Redlock/Redisson/ZK)、Redis 高可用(主从/哨兵/Cluster)、缓存策略(三穿/双层/热Key)


Q1:Redis 分布式锁(RedLock / Redisson / SETNX)

TL;DR

分布式锁演进:SETNX(最简陋,无超时)→ SET NX PX(带超时,但可能误删)→ Redisson(看门狗自动续期 + 可重入 + Lua 原子释放)→ RedLock(多节点投票,防单点故障但争议大)。

类比

🔑 酒店房卡:SETNX = 拿钥匙开门,但忘了还就永远锁着。SET NX PX = 房卡 30 分钟过期,但你还在房里就被赶出来。Redisson = 智能房卡,你在房里自动续期,退房自动释放。RedLock = 酒店有 5 个前台,3 个以上说"房空着"才算真空。

演进对比

方案命令问题解决
SETNXSETNX lock:key 1没超时→死锁—
SET NX PXSET lock:key val NX PX 30000业务超时→锁过期被他人获取→误删value 用唯一 ID 校验
Redisson看门狗定时续期—生产首选
RedLock多节点多数派性能差,争议大极端场景才用

Redisson 看门狗

// Redisson 自动续期机制
RLock lock = redisson.getLock("lock:order:123");
 
// 加锁(默认 30s 超时,看门狗每 10s 续期到 30s)
lock.lock();
try {
    // 业务逻辑(即使执行 5 分钟,锁也不会过期)
    processOrder();
} finally {
    // 释放时校验:确保是自己加的锁(Lua 原子)
    lock.unlock();
}
 
// 看门狗原理:
// 1. 加锁成功 → 启动定时任务(每 internalLockLeaseTime/3 续期)
// 2. 续期:if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) 
//            then redis.call('pexpire', KEYS[1], ARGV[1]); 
// 3. 释放时停止定时任务

Lua 原子释放(防止误删)

-- 只有 value 匹配才删除(防止删了别人的锁)
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end

记忆锚

"SETNX 会死锁,SET NX PX 会误删,Redisson 看门狗是生产标配"


Q2:Redis 主从切换瞬间如何避免分布式锁失效?

TL;DR

主从切换丢锁 = 主节点加锁成功 → 主宕机 → 锁数据还没同步到从节点 → 从提升为主 → 锁丢失 → 另一个客户端能加同一把锁。解决:RedLock(多节点多数派)或 fencing token(单调递增序号防旧写)。

类比

🏨 酒店前台换班:你在前台 A 登记入住(加锁),前台 A 突然晕倒,前台 B 接班。但 B 的登记本上没你的记录(主从延迟)→ B 把同一间房又开给了别人。

问题图解

interview redis cache qa · 图 1
interview redis cache qa · 图 1 · 点击查看 SVG 原图

解决方案

方案 1:RedLock(多数派)

不是单节点加锁,而是向 5 个独立 Redis 节点依次加锁
→ 至少 3 个节点加锁成功 → 才算获取锁成功
→ 一个节点故障不影响整体

缺点:性能差(N 次网络往返),业界争议大(Martin Kleppmann 批评)

方案 2:Fencing Token(推荐)

每次加锁成功 → 返回一个单调递增的 token(如 33)
操作数据时附带 token → 存储层拒绝更小 token 的写入
→ 即使锁被重复获取,旧 token 的写入会被拒绝

实现:ZooKeeper zxid / etcd revision / Redis INCR

记忆锚

"主从异步复制是根源→RedLock 多节点投票→Fencing Token 拒旧写"


Q3:Redis 集群主节点宕机,从节点提升的问题和应对

TL;DR

主节点宕机 → Sentinel 选举新主。问题:数据丢失窗口(主宕机前未同步到从的数据永久丢失)+ 脑裂(网络分区导致两个主)。应对:min-replicas-to-write + min-replicas-max-lag 限制写入。

丢失窗口

主节点写入 → 异步复制到从 → 从确认
              ↑
        如果主在这之前宕机 → 这期间的写入永久丢失

估算:repl-backlog-size 内的数据可能保留,之外的永久丢失

应对配置

# 至少 1 个从节点确认才写入(牺牲可用性换一致性)
min-replicas-to-write 1
min-replicas-max-lag 10  # 从节点延迟超过 10s → 主拒绝写入
 
# 脑裂应对:哨兵配置
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 5000
# → 至少 2 个哨兵同意才做主从切换

记忆锚

"异步复制有丢失窗口→min-replicas 限写入→哨兵多数派防脑裂"


Q4:缓存三穿(穿透/击穿/雪崩)完整方案

TL;DR

穿透(查不存在的数据→打 DB)→ 布隆过滤器拦截。击穿(热点 Key 过期→大量请求打 DB)→ 互斥锁单线程查 DB。雪崩(大量 Key 同时过期→DB 瞬间高压)→ 随机 TTL。

类比

🧅 洋葱防御三层:穿透 = 有人假装送快递想进小区(查不存在的数据),门卫(布隆过滤器)直接拦。击穿 = 网红店排队(热点 Key),店员一次只放一个人进去(互斥锁)。雪崩 = 超市所有打折商品同时到期→大妈们同时冲进来→随机延后过期时间分散压力。

三穿对比

穿透击穿雪崩
现象查不存在的数据,缓存永远 miss热点 Key 过期瞬间大量请求大量 Key 同时过期
攻击目标DBDBDB + Redis
方案布隆过滤器 + 空值缓存互斥锁 + 永不过期随机 TTL + 多级缓存

代码实现

// 1. 穿透:布隆过滤器
public Order getOrder(String orderId) {
    if (!bloomFilter.mightContain(orderId)) {
        return null; // 一定不存在,直接返回
    }
    // 可能存在于缓存或 DB
    return getFromCacheOrDb(orderId);
}
 
// 2. 击穿:互斥锁
public Product getHotProduct(String productId) {
    Product p = redis.get(productId);
    if (p != null) return p;
    
    // 只有一个线程去查 DB
    String lockKey = "lock:product:" + productId;
    if (redis.set(lockKey, "1", "NX", "PX", 5000)) {
        try {
            p = db.query(productId);
            redis.set(productId, p, 60, TimeUnit.SECONDS);
        } finally {
            redis.del(lockKey);
        }
    } else {
        Thread.sleep(50); // 等持有锁的线程写完缓存
        return redis.get(productId);
    }
    return p;
}
 
// 3. 雪崩:随机 TTL
redis.set(key, value, 3600 + ThreadLocalRandom.current().nextInt(600), TimeUnit.SECONDS);
// → TTL = 3600~4200s,避免同时过期

记忆锚

"穿透布隆拦,击穿互斥锁,雪崩随机 TTL"


Q5:双层缓存设计(内存 + Redis)

TL;DR

双层缓存 = Caffeine(JVM 本地) + Redis(分布式)。本地缓存极快(纳秒级)但不同步,Redis 较慢(毫秒级)但全局一致。核心问题:两层之间的数据一致性如何保证。

类比

🏠 家里冰箱 + 楼下超市:本地缓存 = 冰箱(拿东西秒级,但每家冰箱内容不同)。Redis = 楼下超市(东西多,走几分钟,所有人看到的库存一样)。通常先翻冰箱,没找到再去超市。

架构

public Data getData(String key) {
    // L1:本地缓存(Caffeine,纳秒级)
    Data data = caffeineCache.getIfPresent(key);
    if (data != null) return data;
    
    // L2:Redis(毫秒级)
    data = redis.get(key);
    if (data != null) {
        caffeineCache.put(key, data); // 回填 L1
        return data;
    }
    
    // L3:DB
    data = db.query(key);
    redis.set(key, data, ttl);
    caffeineCache.put(key, data);
    return data;
}

一致性问题 + 解决

问题:A 实例修改了 Redis → B 实例的本地缓存还是旧数据

方案 1(推荐):Redis Pub/Sub 通知失效
  → 修改 Redis → 发布消息 "key:xxx 已更新"
  → 所有实例收到 → 删除本地缓存中的 key
  → 实现:Redis Pub/Sub 或 Kafka 广播

方案 2:短 TTL 兜底
  → 本地缓存 TTL 设短(如 5 秒)
  → 5 秒后自动过期,下次从 Redis 拉新数据
  → 简单但 5 秒内不一致

方案 3:Canal 监听 binlog
  → DB 变更 → Canal 捕获 → 通知所有实例刷新

什么场景适合双层缓存?

✅ 适合:
  - 风控规则(读多写少,规则版本更新通过 Pub/Sub 通知)
  - 用户画像数据(读极多,写极少)
  - 币种基础信息(几乎不变)

❌ 不适合:
  - 实时价格(变化太快,本地缓存延迟不可接受)
  - 用户余额(必须强一致,不缓存或极短 TTL)

记忆锚

"Caffeine 求快,Redis 求准,Pub/Sub 通知求一致,短 TTL 兜底"


Q6:本地缓存技术选型

TL;DR

Java 本地缓存三选一:Caffeine(W-TinyLFU,目前最优)> Guava Cache > Ehcache。Caffeine 接近最优命中率,是 Spring Boot 默认的缓存实现。

对比

CaffeineGuava CacheEhcache
淘汰算法W-TinyLFU(最优)LRULRU / LFU / FIFO
性能⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Spring 集成✅ 原生支持✅✅
持久化❌ 纯内存❌ 纯内存✅ 支持磁盘
活跃度活跃(Caffeine 2.x)维护模式活跃(Ehcache 3.x)

Caffeine 配置

Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)                       // 最多 1 万条
    .expireAfterWrite(60, TimeUnit.SECONDS)    // 写后 60s 过期
    .expireAfterAccess(30, TimeUnit.SECONDS)   // 30s 无访问过期
    .recordStats()                              // 开启统计
    .build();

记忆锚

"Caffeine 最先进(W-TinyLFU),Guava 够用,Ehcache 要持久化才选"


Q7:Redis 持久化 RDB vs AOF

TL;DR

RDB = 定时快照(二进制,恢复快,可能丢数据)。AOF = 写命令日志(文本,数据安全,恢复慢)。交易系统推荐:RDB + AOF 混合(Redis 4.0+),RDB 做快速恢复,AOF 补全快照后的增量。

对比

RDBAOF
原理fork 子进程把内存快照写到磁盘每条写命令追加到 AOF 文件
文件大小小(压缩的二进制)大(文本命令)
恢复速度快(直接加载)慢(逐条重放命令)
数据安全可能丢失最后一次快照后的数据高(可配置每次写刷盘)
性能影响fork 时短暂阻塞持续轻微影响
交易系统推荐作为快速恢复的基底AOF 补全 RDB 快照后的数据

混合持久化(Redis 4.0+)

aof-use-rdb-preamble yes

原理:
  AOF 文件前半部分 = RDB 格式快照(加载快)
  AOF 文件后半部分 = AOF 增量命令(安全)
  
重启时:先加载 RDB 部分(秒级恢复)→ 再重放增量 AOF(补全数据)

记忆锚

"RDB 快恢复,AOF 保安全,混合持久化两者兼得——交易系统标配"


Q8:Redis 集群模式对比

TL;DR

三种模式:主从(最简单,手动切换)→ 哨兵 Sentinel(自动故障转移,但仍是单主写入)→ Cluster(数据分片,多主写入,真正分布式)。

对比

主从哨兵 SentinelCluster
数据分片❌ 无❌ 无✅ 16384 哈希槽
故障转移手动自动自动
可写节点仅主节点仅主节点多个主节点
最大容量单机内存单机内存N × 单机内存
复杂度⭐⭐⭐⭐⭐⭐⭐
适用开发环境生产环境中小规模大规模生产

哨兵核心机制

1. 监控:Sentinel 定期 PING 主节点
2. 主观下线(SDOWN):一个 Sentinel 认为主挂了
3. 客观下线(ODOWN):多数(≥ quorum)Sentinel 认为挂了
4. 选举 Leader Sentinel:由 Leader 执行故障转移
5. 故障转移:选新主 + 通知客户端

Cluster 哈希槽

16384 个槽 → 均匀分布到 N 个主节点
key → CRC16(key) % 16384 → 槽号 → 路由到对应节点

扩缩容:迁移部分槽(不是所有 key 重新 hash!)
→ 比一致性哈希更简单、更高效

记忆锚

"主从手动切,哨兵自动切但单主写,Cluster 多主写 + 哈希槽分片"


Q9:Redis 数据结构底层原理

TL;DR

Redis 五大数据类型底层实现:String = SDS(简单动态字符串)、List = Quicklist(双向链表+压缩列表)、Hash = ziplist→hashtable、Set = intset→hashtable、ZSet = ziplist→skiplist+hashtable。核心优化:小数据用紧凑结构(ziplist/intset),大数据切换为标准结构。

底层映射

数据类型小数据编码大数据编码切换阈值
Stringraw / embstrraw—
Listquicklistquicklist—
Hashziplisthashtablehash-max-ziplist-entries=512
Setintsethashtableset-max-intset-entries=512
ZSetziplistskiplist + dictzset-max-ziplist-entries=128

ZSet 为什么用跳表?

跳表(SkipList):
  - 多层索引,查找 O(logN)
  - 插入 O(logN)(概率均衡,不需要旋转)
  - 实现简单(比红黑树少很多代码)
  - 天然支持范围查询(ZRANGE)
  
红黑树也能做,但:
  - 实现复杂(旋转/变色)
  - 范围查询需要中序遍历
  → 跳表是 ZSet 的最优选择

记忆锚

"小数据用紧凑结构省内存,大数据切标准结构追求性能"


Q10:Redis 大 Key 与热 Key 治理

TL;DR

大 Key = 单个 Key 的 value 过大(如哈希表 100 万字段)→ 删除阻塞 Redis → 用 UNLINK 异步删。热 Key = 单个 Key QPS 过高(如秒杀商品)→ 打散到多个 Key 或本地缓存。

大 Key 问题

大 Key = 单个 value > 10MB 或 集合元素 > 10 万

危害:
  1. 读取慢(网络传输 10MB+)
  2. 删除阻塞(DEL 命令 O(N),10 万元素删 1 秒)
  3. 迁移慢(Cluster 迁移槽时卡住)

发现:redis-cli --bigkeys / MEMORY USAGE key

解决:
  - 拆分:user:123:profile → user:123:name, user:123:avatar...
  - 异步删除:UNLINK key(Redis 4.0+,后台线程删)
  - 清理:SCAN + UNLINK 批量清理

热 Key 问题

热 Key = 单个 Key QPS > 10000(如爆款商品库存)

危害:
  1. 单节点 CPU 打满(所有请求打到同一节点)
  2. 带宽瓶颈(所有网卡流量集中)

解决:
  1. 打散:stock:item:123 → stock:item:123:seg1 ~ seg10(分段库存)
  2. 本地缓存:Caffeine 缓存热点数据,1s 刷新一次
  3. 读写分离:热 Key 的读请求走从节点

记忆锚

"大 Key UNLINK 异步删,热 Key 打散分段 + 本地缓存"


Q11:分布式锁续期(看门狗)和锁误删

TL;DR

锁续期 = Redisson 看门狗定时延长锁过期时间(默认每 10s 续期到 30s)。锁误删 = A 的业务超时锁自动过期 → B 获取锁 → A 释放时把 B 的锁删了 → 用唯一 value(UUID)校验,只删自己的锁。

锁误删场景

interview redis cache qa · 图 2
interview redis cache qa · 图 2 · 点击查看 SVG 原图

防止误删:Lua 原子校验

-- key 存在且 value 是自己的 UUID 才删除
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end

记忆锚

"续期靠看门狗,防误删靠 UUID + Lua 原子校验"


Q12:设计一个简单的分布式锁服务

TL;DR

最小分布式锁 = 加锁(SET NX PX + UUID)→ 释放(Lua 校验 UUID 后 DEL)→ 续期(定时任务延长过期时间)→ 极端情况:网络分区时需用 fencing token 防旧写。

口述架构

1. 加锁:
   SET lock:resource:1 {uuid} NX PX 30000
   → NX:仅当不存在才成功(互斥)
   → PX 30000:30 秒自动过期(防死锁)
   → uuid:释放时校验身份(防误删)

2. 释放:
   Lua:if get == myUUID then DEL
   → 原子操作,不会误删别人的锁

3. 续期:
   后台线程每 10s 执行:if get == myUUID then PEXPIRE 30000
   → 业务没执行完,锁不会过期

4. 可重入:
   Hash 结构:HINCRBY lock:key {uuid}:count 1
   → 同一线程可多次获取,count 计数

5. 极端情况(网络分区):
   客户端 A 被分区 → 锁过期 → 客户端 B 获取锁
   → A 恢复后仍认为自己有锁 → 数据错乱
   → 解决:fencing token(存储层拒绝旧 token 的写入)

记忆锚

"SET NX PX 加锁 → Lua UUID 校验释放 → 定时续期 → fencing token 防分区"


Q13:分布式锁——Redis vs Etcd

TL;DR

Redis = 高性能(AP 模型),适合性能敏感但对一致性格外要求不极端的场景。Etcd/ZooKeeper = 强一致(CP 模型),适合对一致性要求极高的场景(如选主)。交易所资产锁推荐 Etcd。

对比

Redis(RedLock/Redisson)Etcd / ZooKeeper
CAPAP(优先可用性)CP(优先一致性)
一致性最终一致(主从异步)强一致(Raft 多数派)
性能⭐⭐⭐⭐⭐(内存级)⭐⭐⭐(需 Raft 共识)
锁续期看门狗自动续期Lease 自动续约
死锁处理TTL 过期自动释放Session 断开自动释放
适用高频低延迟场景资产/选主/配置锁

选型建议

风控规则热更新锁 → Redis(高频,锁持有时间短)
用户资产冻结锁 → Etcd(强一致,钱不能错)
分布式定时任务选主 → Etcd(必须 CP)
秒杀库存扣减锁 → Redis(高性能)

记忆锚

"Redis 快但不完全准,Etcd 准但不快——钱的事用 Etcd,性能的事用 Redis"


Q14:Redis 集群为什么用哈希槽而非一致性哈希?

TL;DR

哈希槽(16384 个槽)比一致性哈希好在:扩缩容只迁移部分槽(而非重算全部 key)、客户端缓存槽映射(一次知道去哪个节点)、槽范围绑定(节点负责连续槽号,管理简单)。

对比

一致性哈希哈希槽(Cluster)
分片粒度一个节点负责一个弧段一个节点负责多个不连续槽
扩缩容只影响相邻节点任意节点间迁移槽
客户端路由需额外维护虚拟节点映射直接计算 CRC16(key) % 16384
槽数理论上无限(虚拟节点)16384 个(足够大,心跳包小)

为什么是 16384?

1. 心跳包大小合理:每个槽占 1 bit(共 2048 字节),16k 个槽刚好
2. 足够大:单集群最多 1000 个节点,每个节点平均 16 个槽
3. 不是越大越好:65536 个槽 → 心跳包 8KB → 太大了

记忆锚

"槽不连续分配→扩缩容灵活→客户端 CRC16 直接算→16384 是心跳包最优数"


Q15:Redis 实现复杂数据结构案例

TL;DR

Redis 不仅是 KV 缓存。ZSet 可以做延迟队列(score=执行时间戳)、频控计数器(score=时间窗口内计数)、时间线(score=时间戳)。BitMap 可以做签到统计、用户在线状态。

案例:ZSet 实现延迟队列

// 生产者:添加延迟任务
redis.zadd("delay:queue", System.currentTimeMillis() + 5000, taskId);
 
// 消费者:取出到期的任务
Set<String> tasks = redis.zrangeByScore("delay:queue", 0, System.currentTimeMillis());
for (String taskId : tasks) {
    // 原子移除并处理
    if (redis.zrem("delay:queue", taskId) > 0) {
        executeTask(taskId);
    }
}

案例:BitMap 实现签到统计

// 用户 1001 在 2025 年第 100 天签到
redis.setbit("sign:2025:1001", 100, 1);
 
// 统计该用户今年签到天数
long count = redis.bitcount("sign:2025:1001");
 
// 统计今天签到总人数
redis.bitop("AND", "sign:today:all", "sign:2025:*");

记忆锚

"ZSet 做延迟队列,BitMap 做签到——Redis 远不止缓存"


Q16:热点数据防止缓存击穿——除了互斥锁还有什么方案?

TL;DR

三种方案从快到"绝":互斥锁(标准方案)→ 永不过期 + 异步更新(零击穿)→ 逻辑过期 + 后台线程(不阻塞用户)。

方案对比

方案原理击穿风险实时性复杂度
互斥锁单线程查 DB有(锁等待)好⭐
永不过期不设 TTL,异步更新零差⭐⭐
逻辑过期value 含 expireTime,后台更新零好⭐⭐⭐

推荐方案:逻辑过期

// 缓存值包装
class CacheData<T> {
    T data;
    long expireAt;  // 逻辑过期时间
}
 
public Product getProduct(String id) {
    CacheData<Product> cache = redis.get(id);
    if (cache == null) {
        return loadFromDb(id);  // 真的 miss
    }
    
    if (cache.expireAt > System.currentTimeMillis()) {
        return cache.data;  // 未过期,直接返回
    }
    
    // 逻辑过期 → 先返回旧数据,后台异步更新
    executor.submit(() -> {
        if (redis.setnx("lock:refresh:" + id, "1", 10)) {
            Product newData = db.query(id);
            redis.set(id, new CacheData<>(newData, now + 30000));
            redis.del("lock:refresh:" + id);
        }
    });
    
    return cache.data;  // 返回旧数据(不阻塞用户!)
}

记忆锚

"互斥锁兜底,逻辑过期最优——返回旧数据不阻塞,后台悄悄刷新"


Q17:缓存与数据库一致性 → 详见 B5 Q1

双归 B5+B6。此处强调:Cache Aside + 延时双删是标准答案,面试时不要扯 CDC 除非面试官追问。


Q18:热点库存秒杀设计

TL;DR

库存秒杀 = Redis 分段库存(分 10 个 Key 分散压力)+ Lua 原子预减 + MQ 异步下单 + DB 最终扣减 + 对账。详见 B1 Q1 秒杀系统。

核心链路

1. Redis 分段 DECR(Lua 原子)→ 库存预减
2. 扣减成功 → MQ → 异步创建订单
3. DB 最终扣减 + 唯一索引防超卖
4. 定时对账(Redis vs DB 库存数)

记忆锚

"分段库存 + Lua 原子 + 异步下单 + 对账兜底"


总结

分布式锁 → Redisson 看门狗 > SET NX PX
锁失效 → Fencing Token 防旧写 > RedLock 多数派
缓存三穿 → 布隆/互斥锁/随机 TTL
双层缓存 → Caffeine + Redis + Pub/Sub 通知
Redis HA → 哨兵自动切(中小规模)/ Cluster 分片(大规模)
持久化 → RDB + AOF 混合(交易标配)
热 Key → 分段 + 本地缓存

B6 补充:ConsistentHash 扩缩容(Q19)


Q19:ConsistentHash 扩缩容怎么处理?

TL;DR

一致性哈希 = hash 值映射到一个环上,节点负责环上一段区间。扩容:新节点插入环 → 只影响相邻节点 → 只需迁移相邻节点的部分数据(不是全量 rehash)。这就是比取模 hash 更优的地方。

类比

⭕ 圆桌分蛋糕:取模 hash = 把圆桌切成 N 等份,增加一个人(N+1)整个圆桌重新分→所有蛋糕搬家。一致性哈希 = 圆桌是固定的,每个人管一段弧。新人来了→只从他相邻的那段弧上切走一小块→其他蛋糕不动。

虚拟节点

问题:节点少时,数据倾斜(有的节点管大片弧,有的只负责一小段)

解决:每个物理节点对应 N 个虚拟节点(如 150 个),均匀分布在环上
  → 物理节点 A → 虚拟节点 A0, A1, A2...A149
  → 虚拟节点越多 → 分布越均匀 → 数据越均衡

记忆锚

"取模 hash = 全量搬家,一致性哈希 = 只搬邻居。虚拟节点解倾斜"


下一篇:B7 Kafka / RocketMQ 消息队列深度(18 题)