分页优化


分页的性能问题

排行榜上线后,用户反馈遇到了新问题:

【用户反馈】用户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 个分片全部要重新查
→ 重建期间会有大量回源

解决办法:分片独立失效 + 异步预热。

失效策略:
    只失效"受影响"的分片
    → 名次变化只影响它所在分片附近的几个分片
    → 精确一点:记录每个分片的名次范围,变化超出范围才失效

预热策略:
    榜单更新后,后台任务逐步重建热门分片
    → 用户访问时大概率命中

分片大小的取舍:

分片大小分片数失效成本缓存粒度
20500高(要失效很多)细,翻页准
100100中适中
50020低粗,翻页要读多余数据

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

如何实现”快速跳转”功能(跳转到指定页)?

分页性能优化Redis

解题思路:

这道题问的是排行榜的分页跳转,核心是『ZSET 的按 rank 取值在深页时很慢,要换成按分数定位』。

详细步骤:

方案:使用 ZRANGEBYSCORE

实现步骤:

  1. 判断跳转目标:跳到第 N 名 → ZRANGE key N-1 N WITHSCORES 取该名的分数作为锚点
  2. 跳到第 N 页 → 先算 offset = (N-1) * pageSize,再用锚点分数定位
  3. 用 ZRANGEBYSCORE key (anchor +inf LIMIT offset count 取整页
  4. 结合游标分页,页与页之间用上一页末尾的分数续查

注意:

  • 直接用 ZRANGE key start stop 跳到很深的页会遍历大量元素,要限制最大可跳转页数
  • 分数相同时元素按 member 字典序排序,锚点要同时用 score + member 唯一确定

最终答案:

用 ZRANGEBYSCORE 按分数定位:先通过一次 ZRANK 拿到目标位置,再按该位置的分数用 ZRANGEBYSCORE 取整页数据。深分页时更稳妥的做法是只提供『跳到第 N 名』而不是『跳到第 N 页』——用 ZRANGE key N-1 N WITHSCORES 直接取第 N 名的分数作为游标,再从该分数往后取一页,避免遍历前 N 个元素。

练习 2

如何实现”每页大小可变”的分页?

分页灵活设计用户体验

解题思路:

这道题问的是页大小不固定时怎么做分页,核心是『游标要能兼容不同的 pageSize』。

详细步骤:

方案:使用游标,支持动态页面大小

实现步骤:

  1. 返回体带游标:{ items: [...], nextCursor: "score|member" }
  2. 请求携带 cursor 与 size,后端解析游标得到锚点
  3. 查询:ZRANGEBYSCORE key (anchor +inf LIMIT 0 size
  4. 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 —— 后面的人不跳号

实现要点:

  1. 同分排序:ZSET 同分数时按 member 字典序,保证结果稳定可复现
  2. 名次推导:Redis 的 ZRANK 返回的是位置序号,不区分并列口径
    • 需要竞赛式:在应用层按分数分组推导,遇到相同分数跳号
    • 需要稠密式:按不同分数的数量计数
  3. 分页要保持口径一致,否则翻页后名次会跳变

注意:

  • 同分人数多时,跨页边界要保证同一分数的成员不被拆到两页造成名次错乱

最终答案:

用 ZSET 的 member 字典序作为同分时的次级排序键,保证顺序确定且可复现;展示时要明确定义用竞赛式排名(1,2,2,4)还是稠密排名(1,2,2,3)并在接口中保持一致——Redis 的 ZRANK 给的是位置序号(会跳号),若需要竞赛式名次要在应用层根据分数自行推导。

练习 4

如何实现”分页缓存”的自动刷新?

缓存自动刷新定时任务

解题思路:

这道题问的是分页结果被缓存后怎么保证不会一直是旧数据,核心是『缓存失效时机由谁决定』。

详细步骤:

方案:定时刷新缓存

实现步骤:

  1. 缓存 key:rank:page:{page}:{size},TTL 设置为 30~60 秒
  2. 定时任务每 10~30 秒重算一次热门页并覆盖写入缓存
  3. 写操作触发精准失效:某文章点赞数变化时,把可能受影响的页(按排名位置估算)标记为脏
  4. 脏页在下次读取时重新计算,或由定时任务统一刷新

注意:

  • 定时刷新要限速,避免和正常请求抢 Redis
  • 缓存穿透要用空值占位或布隆过滤器兜住

最终答案:

用定时刷新(主动刷新)加短 TTL(被动兜底):为排行榜分页缓存设置较短的 TTL(如 30~60 秒)保证最终会过期,同时由定时任务按固定周期主动重算并覆盖热门页的缓存,让数据最多滞后一个刷新周期。写操作(ZINCRBY)之后可以只做精准失效——把受影响的页标记为待刷新,而不是全量清缓存。

练习 5

如何实现”分页预加载”?

分页预加载性能优化

解题思路:

这道题问的是用户还没翻页时就把下一页准备好,核心是『在客户端预取还是在服务端预热』。

详细步骤:

方案:预加载下一页

实现步骤:

  1. 触发时机:滚动到列表底部 200px 时通过 IntersectionObserver 触发,而不是 scroll 事件
  2. 预取参数:用上一页返回的 nextCursor + 相同的 size
  3. 结果缓存:预取数据存前端内存,命中时直接渲染,并标记该页已预取
  4. 去重与并发控制:同一页只允许一个预取请求在途

注意:

  • 预取会增加无效流量,要限制预取深度(通常只预取 1~2 页)
  • 数据实时性要求高时,预取页的过期时间要短,或在真正展示时校验版本

最终答案:

客户端预取:滚动到底部时用上一页返回的游标预请求下一页数据并缓存到内存,滚动时直接渲染;同时用 IntersectionObserver 做懒触发,避免一次加载过多。服务端侧配合把预取请求与正式请求区分开,并让预取结果只做短时间缓存,减少数据过期带来的不一致。


思考题

  1. 如何实现”分页导出”功能(导出 Excel)?

  2. 如何处理”分页数据实时变化”的问题?

  3. 如何实现”多维度排序”的分页(按时间、按热度等)?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。