分页优化
排行榜上线后,用户反馈遇到了新问题:
【用户反馈】用户ID: 5678
问题:查看第 100 页时,加载非常慢
【用户反馈】用户ID: 1234
问题:排行榜有 10000 篇文章,但只能翻到第 500 页
【监控数据】
第 1 页:响应时间 50ms
第 10 页:响应时间 200ms
第 50 页:响应时间 2s
第 100 页:响应时间 8s
第 500 页:响应时间 30s+
问题:深分页性能差。
传统分页的问题
性能问题:
ZREVRANGE 时间复杂度:O(log N + M)
N: 集合总大小
M: 返回元素数量
第 1 页:
- log N + M ≈ log 10000 + 20 ≈ 14 + 20 = 34
第 100 页:
- log N + M ≈ log 10000 + 20 ≈ 34
- 但需要先找到第 1980 个元素
- 实际复杂度更高
问题:
- Redis 仍需遍历到起始位置
- 深分页慢
- 大数据量时性能差
数据库分页的问题
如果使用数据库分页:
数据设计要点
- 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。
性能问题:
OFFSET 的问题:
- 需要扫描前 1980 条记录
- 然后返回后 20 条
- 扫描的数据白白浪费
第 1 页:扫描 20 条
第 100 页:扫描 2000 条
第 500 页:扫描 10000 条
性能随页数增长而下降
方案 1:限制最大页数
优点:
- 实现简单
- 性能可控
缺点:
- 用户无法查看所有数据
- 可能影响用户体验
方案 2:游标分页(推荐)
优点:
- 性能稳定(每次查询都是 O(log N + M))
- 支持无限翻页
- 用户体验好
缺点:
- 不能跳到指定页
- 需要前端配合
方案 3:双向游标
单向游标只能”往下翻”,用户想回看上一页就得重新从第一页拉起。双向游标在游标里额外带上一个方向标记,让服务端知道是往前翻还是往后翻。
class BiDirectionalCursor:
"""双向游标分页:支持往前和往后翻页"""
def __init__(self, redis_client, page_size=20):
self.redis = redis_client
self.page_size = page_size
def get_page(self, key, cursor=None, direction="next", limit=None):
"""
cursor 格式:{score}:{member}:{direction}
direction: next(往新翻)/ prev(往旧翻)
"""
limit = limit or self.page_size
if cursor is None:
# 首页:从最新开始
members = self.redis.zrevrange(key, 0, limit - 1, withscores=True)
else:
last_score, last_member, cursor_dir = self.parse_cursor(cursor)
# 游标自带方向优先,其次用参数指定的方向
effective_dir = cursor_dir or direction
if effective_dir == "next":
# 往更新的方向翻:score < 游标
members = self.redis.zrevrangebyscore(
key, max=f"({last_score}", min="-inf", withscores=True
)
members = self._filter_same_score(members, last_score, last_member, keep_greater=False)
else:
# 往更旧的方向翻:score > 游标
members = self.redis.zrevrangebyscore(
key, max="+inf", min=f"({last_score}", withscores=True
)
members = self._filter_same_score(members, last_score, last_member, keep_greater=True)
members = members[:limit]
if not members:
return {"items": [], "next_cursor": None, "prev_cursor": None}
# 生成前后两个游标
first = members[0]
last = members[-1]
return {
"items": [
{"article_id": int(m), "like_count": int(s)} for m, s in members
],
"next_cursor": self.build_cursor(last[1], last[0], "next"),
"prev_cursor": self.build_cursor(first[1], first[0], "prev"),
}
def _filter_same_score(self, members, score, member, keep_greater):
"""同分记录的二次过滤,保证不重不漏"""
result = []
for m, s in members:
if int(s) == score:
if keep_greater and m > member:
continue
if not keep_greater and m < member:
continue
result.append((m, s))
return result
def build_cursor(self, score, member, direction):
return f"{int(score)}:{member}:{direction}"
def parse_cursor(self, cursor):
parts = cursor.split(":")
if len(parts) < 2:
return 0, "", None
score = int(parts[0])
member = parts[1]
direction = parts[2] if len(parts) > 2 else None
return score, member, direction
双向游标的关键是”每个游标都携带方向”。
用户从第 3 页点"上一页"
→ 前端把第 3 页的 prev_cursor 发回服务端
→ 这个游标里带着 direction = "prev"
→ 服务端知道要往更旧的方向查
为什么方向要存在游标里,而不是只靠请求参数?
只用请求参数的问题:
用户在第 3 页点了"上一页" → direction=prev ✅
用户在第 3 页点了"下一页" → direction=next ✅
但如果用户返回上一页后又点了"下一页",语义就乱了
→ 历史记录、书签、分享链接都会出问题
游标自带方向:
每个游标明确说"从我这里往哪边翻"
→ 前端只需要把游标原样传回,不需要维护方向状态
双向游标让”返回上一页”变成 O(log N + M)。
单向游标 + 重新拉取:
用户在第 50 页点"上一页"
→ 客户端必须从第 1 页开始一路翻到第 49 页 ❌
双向游标:
→ 直接用第 50 页的 prev_cursor,一次查询拿到第 49 页 ✅
双向游标的代价:实现复杂度明显上升。
- 游标格式变复杂(多一个方向位)
- 同分记录的过滤逻辑要写两遍(两个方向)
- 前端要同时维护 next_cursor 和 prev_cursor
- 边界处理:首页没有 prev_cursor,末页没有 next_cursor
“回到顶部”是一个特例。
用户滚了很久,想回到最新的一页
→ 不能靠"往前翻 N 次"
→ 需要一个"回到最新"的入口
→ 实现:cursor 传 null,服务端返回第一页
实现要点:
前端记录"是否在第 1 页":
在第 1 页 → "回到最新"按钮直接重置 cursor = null
不在第 1 页 → 显示"回到最新",点击后 cursor = null
方案 4:分片缓存
前三个方案优化的是”查询”,分片缓存优化的是”不查询”。
把榜单按名次切成若干片,每片缓存一份:
cache:ranking:shard:0 → 第 1~100 名
cache:ranking:shard:1 → 第 101~200 名
cache:ranking:shard:2 → 第 201~300 名
def get_shard(self, shard_index, shard_size=100, ttl=30):
"""读取指定分片"""
key = f"cache:ranking:shard:{shard_index}"
cached = self.redis.get(key)
if cached is not None:
return json.loads(cached)
start = shard_index * shard_size
members = self.redis.zrevrange(
"ranking:articles:hot", start, start + shard_size - 1, withscores=True
)
result = [
{"rank": start + i + 1, "article_id": int(m), "like_count": int(s)}
for i, (m, s) in enumerate(members)
]
self.redis.setex(key, ttl, json.dumps(result))
return result
def get_page(self, page, page_size=20):
"""普通页码分页:转成分片读取"""
shard_size = 100
shard_index = (page * page_size) // shard_size
offset = (page * page_size) % shard_size
shard = self.get_shard(shard_index, shard_size)
return shard[offset:offset + page_size]
分片缓存解决了深分页的问题。
没有分片缓存:
第 500 页 → ZREVRANGE 起始位置 9980
→ Redis 要跳过前 9980 个元素
→ 响应时间 30 秒
有分片缓存:
第 500 页 → 命中分片 99(缓存里已经是第 9901~10000 名)
→ 直接切片,响应时间 10ms
分片缓存让”深分页”变成了 O(1)。
命中缓存:切片操作 O(page_size)
未命中:只查一个分片,ZREVRANGE 的起始位置是固定的(分片内的偏移)
代价是缓存失效时所有分片都要重建。
榜单变了 → 缓存失效 → 100 个分片全部要重新查
→ 重建期间会有大量回源
解决办法:分片独立失效 + 异步预热。
失效策略:
只失效"受影响"的分片
→ 名次变化只影响它所在分片附近的几个分片
→ 精确一点:记录每个分片的名次范围,变化超出范围才失效
预热策略:
榜单更新后,后台任务逐步重建热门分片
→ 用户访问时大概率命中
分片大小的取舍:
| 分片大小 | 分片数 | 失效成本 | 缓存粒度 |
|---|---|---|---|
| 20 | 500 | 高(要失效很多) | 细,翻页准 |
| 100 | 100 | 中 | 适中 |
| 500 | 20 | 低 | 粗,翻页要读多余数据 |
100 是一个常用的折中值。
分片缓存的另一个价值:可以做”部分失效”。
榜单头部剧烈变化(Top 10 洗牌)
→ 只失效第 0 个分片
→ 其他分片的缓存继续服务
但要注意分片缓存和游标分页的冲突。
游标分页:按 score 定位,天然适配数据变化
分片缓存:按名次分片,数据变化会导致边界错位
用户翻到分片边界时:
缓存的是旧的第 101~200 名
现在实际的第 101 名已经变了
→ 翻页时可能出现重复或遗漏
解决办法:给每个分片缓存打一个”版本号”。
cache:ranking:shard:1 → 数据
cache:ranking:shard:1:ver → 生成时的榜单版本号
读取时:
当前版本 != 缓存版本 → 这个分片失效,重新查
这个版本号可以用一个全局计数器,每次榜单更新就 INCR 一次。
问题:数据库深分页
如果排行榜数据在数据库中,如何优化深分页?
数据设计要点
- 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。
方案:使用覆盖索引
数据设计要点
- 索引服务于高频查询,重点是缩小扫描范围,而不是堆更多字段。
- 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。
性能对比:
传统方式:
- 扫描行数:2020 行
- 执行时间:约 500ms
覆盖索引方式:
- 扫描行数:20 行(只查索引)
- 执行时间:约 50ms
- 提升约 10 倍
虚拟滚动
排行榜可能有几百上千条,前端如果全部渲染,DOM 会变得很重。虚拟滚动只渲染”视口内 + 少量缓冲”的元素。
<div class="ranking-container" style="height: 800px; overflow-y: auto;">
<!-- 占位容器:撑起完整高度,保证滚动条长度正确 -->
<div class="ranking-placeholder" style="height: 1000 * 56px; position: relative;">
<!-- 可见项:整体下移到正确的位置 -->
<div class="ranking-visible" style="transform: translateY(${startIndex * 56}px);">
<!-- 只渲染这 35 个节点 -->
</div>
</div>
</div>
function VirtualRanking({ items, itemHeight = 56, containerHeight = 800 }) {
const [startIndex, setStartIndex] = useState(0)
const visibleCount = Math.ceil(containerHeight / itemHeight)
const buffer = 5
const onScroll = (e) => {
const offset = e.target.scrollTop
const next = Math.max(0, Math.floor(offset / itemHeight) - buffer)
setStartIndex(prev => (prev === next ? prev : next))
}
const endIndex = Math.min(items.length, startIndex + visibleCount + buffer * 2)
const visible = items.slice(startIndex, endIndex)
return (
<div style={{ height: containerHeight, overflowY: 'auto' }} onScroll={onScroll}>
<div style={{ height: items.length * itemHeight, position: 'relative' }}>
<div style={{ transform: `translateY(${startIndex * itemHeight}px)` }}>
{visible.map((item, i) => (
<RankingRow key={item.article_id} item={item} rank={startIndex + i + 1} />
))}
</div>
</div>
</div>
)
}
虚拟滚动在排行榜场景的三个特殊点:
1. 名次要自己算,不能用 CSS 的 order。
虚拟列表里的元素顺序是"渲染顺序",不是"名次顺序"
→ 排名数字要用 startIndex + i 计算
2. 推送更新时不能破坏滚动位置。
用户在第 50 名附近浏览,这时第 3 名发生变化
→ 如果直接重排数组,滚动位置会跳
→ 解决:保持 startIndex 不变,只更新数据,等用户滚动时再重排
3. 固定高度是前提。
上面的实现假设每行 56px。如果行高不固定(标题换行导致高度变化),就要用”预估高度 + 实际测量回填”的方案,复杂度会高很多。排行榜的每一行结构相同,用固定高度最合适。
虚拟滚动的性能收益:
1000 条数据:
全部渲染:1000 个 DOM 节点,内存约 30MB,滚动卡顿
虚拟滚动:35 个 DOM 节点,内存约 1MB,滚动流畅
和懒加载的关系:
| 技术 | 解决什么 |
|---|---|
| 懒加载 | 数据还没获取到,分批请求 |
| 虚拟滚动 | 数据已经拿到了,但不全部渲染 |
两者一起用:滚动到底 → 请求下一页 → 追加到数据数组 → 虚拟滚动重新渲染可见部分。
详细的虚拟滚动实现可以参考《去重展示》一章的”虚拟滚动”一节,那里的讨论同样适用于排行榜。
无限加载
无限加载是游标分页在前端的具体用法:用户滚到底部,自动加载下一页。
class InfiniteRanking {
constructor(apiUrl) {
this.apiUrl = apiUrl
this.items = []
this.cursor = null
this.loading = false
this.hasMore = true
this.observer = null
}
async loadMore() {
// 三重保护:防重复请求
if (this.loading || !this.hasMore) return
this.loading = true
try {
const url = this.cursor
? `${this.apiUrl}?cursor=${encodeURIComponent(this.cursor)}`
: this.apiUrl
const res = await fetch(url)
const data = await res.json()
this.items = this.items.concat(data.items)
this.cursor = data.next_cursor
this.hasMore = data.has_more
this.render()
} finally {
this.loading = false
}
}
observeSentinel() {
// 用 IntersectionObserver 监听哨兵元素
this.observer = new IntersectionObserver(
(entries) => {
if (entries[0].isIntersecting) this.loadMore()
},
{ rootMargin: '200px' } // 提前 200px 开始加载
)
this.observer.observe(this.sentinel)
}
}
rootMargin: '200px' 是无限加载的关键细节。
rootMargin = 0:
哨兵元素完全进入视口才加载
→ 用户会先看到空白,再看到内容
rootMargin = '200px':
哨兵元素距离视口底部还有 200px 时就开始加载
→ 内容加载完成时用户还没滚到那里,体验是"无缝"的
无限加载的四个坑:
1. 快速滚动会触发大量请求。
`loading` 标志位是必须的
→ 没有它,哨兵在视口内时会连续触发多次 loadMore
2. 请求返回顺序可能乱。
第 1 页请求慢,第 2 页请求快
→ 第 2 页先返回并被追加
→ 第 1 页后返回,追加到末尾 → 顺序错了 ❌
解决办法是记录请求序号,返回时检查是否是最新的:
this.requestSeq++
const seq = this.requestSeq
const data = await res.json()
if (seq !== this.requestSeq) return // 有更新的请求了,丢弃这次结果
3. 返回上一页后数据会重复。
用户翻到第 5 页,又滚回第 2 页,再往下滚
→ 游标分页每次都是"继续往后",会重复请求第 3~5 页
→ 数据被重复追加 ❌
这是单向游标的固有限制。双向游标能解决一部分,但要配合前端记录每个页面的游标栈。
4. 浏览器后退会丢失位置。
用户滚到第 20 页,点了浏览器后退,再前进
→ 页面重新加载,回到顶部
解决办法是把游标和页码写进 URL:
/ranking?cursor=xxx&page=20
→ 前进后退都能恢复
无限加载的替代方案:分页按钮。
| 方案 | 优点 | 缺点 |
|---|---|---|
| 无限加载 | 体验流畅,不打断浏览 | 找不到”第几页”,无法分享位置 |
| 分页按钮 | 位置明确,可分享 | 每次点击都有加载延迟 |
很多产品同时提供两者:默认无限加载,底部放一个”查看更多”按钮和”回到顶部”。
不同分页方案对比
场景:10,000 篇文章,查看第 100 页
传统 OFFSET 分页:
- 响应时间:2.5s
- 数据库扫描:2000 行
- 用户体验:差
游标分页:
- 响应时间:50ms
- 数据库扫描:20 行
- 用户体验:好
- 限制:不能跳页
分片缓存:
- 响应时间:10ms
- 数据库扫描:0 行(命中缓存)
- 用户体验:很好
- 限制:需要预热
推荐方案
建议:游标分页 + 分片缓存
前端:
- 使用游标分页
- 支持无限滚动
- 用户体验好
后端:
- 热门页面使用缓存
- 冷门页面使用游标查询
- 性能稳定
练习 1
如何实现”快速跳转”功能(跳转到指定页)?
解题思路:
这道题问的是排行榜的分页跳转,核心是『ZSET 的按 rank 取值在深页时很慢,要换成按分数定位』。
详细步骤:
方案:使用 ZRANGEBYSCORE
实现步骤:
- 判断跳转目标:跳到第 N 名 →
ZRANGE key N-1 N WITHSCORES取该名的分数作为锚点 - 跳到第 N 页 → 先算 offset = (N-1) * pageSize,再用锚点分数定位
- 用
ZRANGEBYSCORE key (anchor +inf LIMIT offset count取整页 - 结合游标分页,页与页之间用上一页末尾的分数续查
注意:
- 直接用
ZRANGE key start stop跳到很深的页会遍历大量元素,要限制最大可跳转页数 - 分数相同时元素按 member 字典序排序,锚点要同时用 score + member 唯一确定
最终答案:
用 ZRANGEBYSCORE 按分数定位:先通过一次 ZRANK 拿到目标位置,再按该位置的分数用 ZRANGEBYSCORE 取整页数据。深分页时更稳妥的做法是只提供『跳到第 N 名』而不是『跳到第 N 页』——用 ZRANGE key N-1 N WITHSCORES 直接取第 N 名的分数作为游标,再从该分数往后取一页,避免遍历前 N 个元素。
练习 2
如何实现”每页大小可变”的分页?
解题思路:
这道题问的是页大小不固定时怎么做分页,核心是『游标要能兼容不同的 pageSize』。
详细步骤:
方案:使用游标,支持动态页面大小
实现步骤:
- 返回体带游标:
{ items: [...], nextCursor: "score|member" } - 请求携带
cursor与size,后端解析游标得到锚点 - 查询:
ZRANGEBYSCORE key (anchor +inf LIMIT 0 size - size 做上下限校验,防止超大页拖垮 Redis
注意:
- 游标要包含 score 与 member,score 相同的情况才能正确定位
- 客户端需要区分『改页大小』和『换排序条件』——换了排序条件必须丢弃旧游标重新开始
最终答案:
用游标分页而不是 offset 分页:下一页的起点由上一页最后一条的 (score, member) 决定,与当前页大小无关,因此用户把每页从 20 改成 50 再翻页也不会错位或重复。后端接口把 cursor(上一页末位的 score + member 编码)和 size 一起传回,size 做上下限校验(如 1~100),并在用户切换排序条件时丢弃旧游标重新开始。
练习 3
如何处理”排名并列”的情况?
解题思路:
这道题问的是分数相同的用户怎么排名,核心是『同分怎么排序、名次怎么算』。
详细步骤:
方案:相同分数的处理
两种排名口径:
- 竞赛式(标准竞赛排名):1, 2, 2, 4 —— 后面的人跳号,与奥运会一致
- 稠密式:1, 2, 2, 3 —— 后面的人不跳号
实现要点:
- 同分排序:ZSET 同分数时按 member 字典序,保证结果稳定可复现
- 名次推导:Redis 的 ZRANK 返回的是位置序号,不区分并列口径
- 需要竞赛式:在应用层按分数分组推导,遇到相同分数跳号
- 需要稠密式:按不同分数的数量计数
- 分页要保持口径一致,否则翻页后名次会跳变
注意:
- 同分人数多时,跨页边界要保证同一分数的成员不被拆到两页造成名次错乱
最终答案:
用 ZSET 的 member 字典序作为同分时的次级排序键,保证顺序确定且可复现;展示时要明确定义用竞赛式排名(1,2,2,4)还是稠密排名(1,2,2,3)并在接口中保持一致——Redis 的 ZRANK 给的是位置序号(会跳号),若需要竞赛式名次要在应用层根据分数自行推导。
练习 4
如何实现”分页缓存”的自动刷新?
解题思路:
这道题问的是分页结果被缓存后怎么保证不会一直是旧数据,核心是『缓存失效时机由谁决定』。
详细步骤:
方案:定时刷新缓存
实现步骤:
- 缓存 key:
rank:page:{page}:{size},TTL 设置为 30~60 秒 - 定时任务每 10~30 秒重算一次热门页并覆盖写入缓存
- 写操作触发精准失效:某文章点赞数变化时,把可能受影响的页(按排名位置估算)标记为脏
- 脏页在下次读取时重新计算,或由定时任务统一刷新
注意:
- 定时刷新要限速,避免和正常请求抢 Redis
- 缓存穿透要用空值占位或布隆过滤器兜住
最终答案:
用定时刷新(主动刷新)加短 TTL(被动兜底):为排行榜分页缓存设置较短的 TTL(如 30~60 秒)保证最终会过期,同时由定时任务按固定周期主动重算并覆盖热门页的缓存,让数据最多滞后一个刷新周期。写操作(ZINCRBY)之后可以只做精准失效——把受影响的页标记为待刷新,而不是全量清缓存。
练习 5
如何实现”分页预加载”?
解题思路:
这道题问的是用户还没翻页时就把下一页准备好,核心是『在客户端预取还是在服务端预热』。
详细步骤:
方案:预加载下一页
实现步骤:
- 触发时机:滚动到列表底部 200px 时通过 IntersectionObserver 触发,而不是 scroll 事件
- 预取参数:用上一页返回的 nextCursor + 相同的 size
- 结果缓存:预取数据存前端内存,命中时直接渲染,并标记该页已预取
- 去重与并发控制:同一页只允许一个预取请求在途
注意:
- 预取会增加无效流量,要限制预取深度(通常只预取 1~2 页)
- 数据实时性要求高时,预取页的过期时间要短,或在真正展示时校验版本
最终答案:
客户端预取:滚动到底部时用上一页返回的游标预请求下一页数据并缓存到内存,滚动时直接渲染;同时用 IntersectionObserver 做懒触发,避免一次加载过多。服务端侧配合把预取请求与正式请求区分开,并让预取结果只做短时间缓存,减少数据过期带来的不一致。
-
如何实现”分页导出”功能(导出 Excel)?
-
如何处理”分页数据实时变化”的问题?
-
如何实现”多维度排序”的分页(按时间、按热度等)?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
