实时排行


实时性的挑战

实现了基础排行榜后,产品经理又提出了新要求:

【需求文档】实时排行榜

功能 1:实时排名
- 点赞后立即看到排名变化
- 排名变化要平滑过渡

功能 2:排名动画
- 排名上升时显示动画
- 高亮显示变化

功能 3:历史排名
- 查看排名历史趋势
- 支持排名对比

需要实现实时更新的排行榜。


实时排名更新

方案 1:每次点赞更新排名

性能问题:

  • 每次点赞都要更新排行榜
  • 高并发时性能差
  • 可能成为瓶颈

方案 2:延迟更新排名

方案 1 每次点赞都更新排行榜,写路径上多了一次 ZINCRBY,而且所有点赞同一篇文章的请求都在竞争 ZSET 的同一个节点。延迟更新的思路是:点赞时只累加增量,定时把增量批量刷进排行榜。

import threading
from collections import defaultdict


class DelayedRankingUpdater:
    """延迟更新:点赞只累加增量,批量刷进排行榜"""

    def __init__(self, redis_client, flush_interval=5.0):
        self.redis = redis_client
        self.flush_interval = flush_interval
        self.buffer = defaultdict(int)
        self._lock = threading.Lock()
        self._stop = threading.Event()
        self._thread = None

    def start(self):
        self._thread = threading.Thread(target=self._run, daemon=True)
        self._thread.start()

    def on_like(self, article_id):
        """点赞:只记增量,不碰排行榜"""
        with self._lock:
            self.buffer[article_id] += 1

    def _run(self):
        while not self._stop.wait(self.flush_interval):
            self.flush()

    def flush(self):
        """把缓冲区的增量批量刷进排行榜"""
        with self._lock:
            pending = self.buffer
            self.buffer = defaultdict(int)
        if not pending:
            return 0

        pipe = self.redis.pipeline()
        for article_id, delta in pending.items():
            pipe.zincrby("ranking:articles:hot", delta, str(article_id))
        pipe.execute()
        return len(pending)

延迟更新的代价是”排名不是实时的”。

T0: 文章 A 点赞 → 缓冲区 +1
T1: 文章 B 点赞 → 缓冲区 +1
T2: 排行榜还没刷新,A 和 B 的排名都还是旧的
T5: 刷新 → 排名更新

5 秒的延迟对排行榜产品形态来说通常可以接受。 用户刷排行榜时看到的本来就是”几秒前的快照”,不是毫秒级的实时。

为什么延迟更新能把吞吐提升这么多?

方案 1(每次点赞更新):
    每个点赞请求都要执行一次 ZINCRBY
    热点文章的 ZSET 节点成为竞争点
    5000 ops/s 的点赞 → 5000 次 ZINCRBY

方案 2(延迟更新):
    点赞请求只做一次内存累加(纳秒级)
    排行榜更新变成 5 秒一次、每次几百条 ZINCRBY
    5000 ops/s 的点赞 → 每 5 秒几百次 ZINCRBY

延迟更新的实现要点:

1. 缓冲区必须在内存里且线程安全。

多个请求线程会同时调用 on_like,所以要有锁。锁的粒度要小——只保护 buffer 的读写,不要把 Redis 调用放进去。

2. 进程重启会丢掉缓冲区。

内存缓冲区的数据在进程崩溃时丢失。这个问题有两个处理方式:

方式 A:缓冲区也放 Redis
    用 HINCRBY 累加增量,定时任务读出来刷进排行榜
    → 数据不丢,但每次点赞多一次 Redis 操作

方式 B:接受丢失
    丢失的量 = 崩溃前未刷新的增量(最多 5 秒的增量)
    → 用对账任务修复排行榜

排行榜数据可以重建,所以方式 B 的实际风险不大。

3. 刷新的粒度要够细。

如果 5 秒内刷了 100 篇文章,排行榜会出现”阶梯式”更新——5 秒内排名完全不变,然后突然跳一格。要让用户感觉平滑,可以把刷新间隔缩短到 1~2 秒。

方案 2 和方案 3(增量更新)怎么选?

方案 2(延迟更新):
    增量在应用进程内存里攒
    → 写路径最快,但多实例时每个实例各刷各的

方案 3(增量更新):
    增量也走 Redis 攒(比如用 Hash 累加)
    → 多实例共享一个缓冲区,写路径多一次 Redis 操作
    → 但更可靠、更好监控

如果系统是多实例部署,方案 3 更稳妥。

方案 3:增量更新(推荐)

方案 3 和方案 2 的区别在于缓冲区放在哪里:方案 2 放在应用进程内存里,方案 3 放在 Redis 里,由所有实例共享。

class RedisBufferRankingUpdater:
    """增量更新:缓冲区在 Redis,所有实例共享"""

    BUFFER_KEY = "ranking:pending:deltas"

    def __init__(self, redis_client, flush_interval=5.0):
        self.redis = redis_client
        self.flush_interval = flush_interval
        self._stop = threading.Event()
        self._thread = None

    def on_like(self, article_id):
        """点赞:往 Redis 的 Hash 里累加增量"""
        self.redis.hincrby(self.BUFFER_KEY, str(article_id), 1)

    def _run(self):
        while not self._stop.wait(self.flush_interval):
            self.flush()

    def flush(self):
        """取出缓冲区的增量,批量刷进排行榜"""
        # 先取出来(原子地),再刷进 ZSET
        pending = self.redis.hgetall(self.BUFFER_KEY)
        if not pending:
            return 0

        # 清空缓冲区(用 HDEL 精确删除,避免丢掉并发写入的新增量)
        pipe = self.redis.pipeline()
        for article_id in pending:
            pipe.hdel(self.BUFFER_KEY, article_id)
            pipe.zincrby("ranking:articles:hot", int(pending[article_id]),
                         article_id)
        pipe.execute()
        return len(pending)

缓冲区放 Redis 的代价:每次点赞多一次 HINCRBY。

方案 2:内存累加 → ~0.0001ms
方案 3:HINCRBY   → ~0.3ms(一次网络往返)

多出来的 0.3ms 换来的是:
- 多实例共享同一个缓冲区
- 进程重启不丢增量
- 缓冲区长度可以直接监控(HLEN)

“取出后清空”这一步要用 HDEL 而不是 DEL。

错误:
    pending = HGETALL buffer
    DEL buffer                 ← 这期间新写入的增量被删掉了 ❌

正确:
    pending = HGETALL buffer
    HDEL buffer {取出的那些 field}   ← 只删取出的,其他保留 ✅

还有更好的做法:用 Lua 脚本把”取出 + 清空”做成原子操作。

-- take_deltas.lua
local deltas = redis.call('HGETALL', KEYS[1])
for i = 1, #deltas, 2 do
    redis.call('HDEL', KEYS[1], deltas[i])
end
return deltas

方案 3 的额外好处:缓冲区可以跨实例”抢刷”。

实例 A 和实例 B 都在跑 5 秒定时任务
→ 谁先跑到谁刷
→ 不会重复刷(因为取和清是原子的)

监控指标更完整。

HLEN ranking:pending:deltas    → 缓冲区积压量
→ 持续增长说明刷新的速度跟不上点赞的速度
→ 积压到某个阈值说明榜单数据已经严重滞后

三个方案的对比:

维度方案 1:每次更新方案 2:延迟更新(内存)方案 3:增量更新(Redis)
写路径开销1 次 ZINCRBY内存累加1 次 HINCRBY
数据时效实时延迟(秒级)延迟(秒级)
多实例共享是否是
崩溃丢失无有(少量)无
写路径竞争高(热点节点)无低(Hash 分散)
实现复杂度低低中

性能对比:

方案 1(每次更新):
- 点赞操作:100 ops/s
- 排行榜更新:100 ops/s
- 总计:200 ops/s

方案 2(延迟更新):
- 点赞操作:5000 ops/s
- 排行榜更新:批量,5 秒一次
- 总计:5000 ops/s(提升 25 倍)

方案 3(增量更新):
- 点赞操作:8000 ops/s
- 排行榜更新:内存操作,极快
- 总计:8000 ops/s(提升 40 倍)

排名历史

记录排名变化

要做”排名趋势”,首先要把排名历史存下来。每次排名变化都记一条,会产生大量数据,要控制采样频率。

def record_rank_change(article_id, old_rank, new_rank, timestamp=None):
    """记录一次排名变化"""
    ts = timestamp or int(time.time())

    # 用 ZSET 存:以时间为 score,以排名为 member
    # 天然按时间排序,也方便查"最近一次排名"
    redis.zadd(
        f"rank:history:article:{article_id}",
        {str(new_rank): ts},
    )
    # 只保留最近 100 条
    redis.zremrangebyrank(f"rank:history:article:{article_id}", 0, -101)

ZSET 是记录排名历史最合适的数据结构。

key:    rank:history:article:123
member: 排名值(字符串化的数字)
score:  记录时间戳

查询"最近一次排名":
    ZRANGE rank:history:article:123 -1 -1 WITHSCORES
    → "5"  1710000000

查询"最近一小时的变化":
    ZRANGEBYSCORE rank:history:article:123 1710000000 +inf WITHSCORES

但 ZSET 的 member 是排名值,同一个排名只能存在一条。

如果文章连续三次都是第 5 名,ZADD 会覆盖掉之前的记录。要保留每一次变化,member 要加上序号:

member = f"{new_rank}:{seq}"     # seq 是自增序号

用 Redis 的 INCR 生成序号:

seq = redis.incr(f"rank:seq:article:{article_id}")
redis.zadd(f"rank:history:article:{article_id}", {f"{new_rank}:{seq}": ts})

记录排名变化的时机不能太频繁。

每次点赞都记录:
    1000 ops/s → 每秒 1000 条记录 → 每天 8600 万条 ❌

规则化采样:
    - 排名变化超过 N 位才记(比如变化 ≥ 3 位)
    - 或者每 M 秒最多记一条
    - 或者只在"进入/退出 Top N"时记

生产环境里推荐”记录显著变化”:

def record_rank_change(article_id, old_rank, new_rank):
    """只记录显著的变化"""
    if old_rank is None or new_rank is None:
        return
    # 变化幅度太小不记录
    if abs(old_rank - new_rank) < 3:
        return
    # 只关心 Top 100 的变化
    if new_rank > 100:
        return
    ...

批量记录排名变化用 Pipeline。

def record_batch(article_id, changes):
    """批量记录排名变化"""
    pipe = redis.pipeline()
    seq = redis.incr(f"rank:seq:article:{article_id}")
    for rank, ts in changes:
        pipe.zadd(f"rank:history:article:{article_id}", {f"{rank}:{seq}": ts})
    pipe.execute()

排名趋势分析

有了排名历史,就可以算出各种趋势指标。

def get_rank_trend(article_id, hours=24):
    """获取排名趋势数据"""
    since = int(time.time()) - hours * 3600
    key = f"rank:history:article:{article_id}"

    records = redis.zrangebyscore(key, since, "+inf", withscores=True)
    if not records:
        return None

    points = []
    for member, score in records:
        rank = int(member.split(":")[0])
        points.append({"timestamp": int(score), "rank": rank})

    points.sort(key=lambda p: p["timestamp"])

    ranks = [p["rank"] for p in points]
    return {
        "article_id": article_id,
        "points": points,
        "current_rank": ranks[-1],
        "best_rank": min(ranks),
        "worst_rank": max(ranks),
        "trend": calculate_trend(ranks),
    }


def calculate_trend(ranks):
    """判断趋势:上升 / 下降 / 平稳"""
    if len(ranks) < 2:
        return "stable"

    # 用最近 1/4 和最近 1/3 的均值对比,抵消单点噪声
    quarter = max(1, len(ranks) // 4)
    third = max(1, len(ranks) // 3)

    old_avg = sum(ranks[:quarter]) / quarter
    new_avg = sum(ranks[-third:]) / third

    # 排名数字越小越好,所以 new_avg 更小意味着上升
    if old_avg - new_avg > 1:
        return "rising"
    if new_avg - old_avg > 1:
        return "falling"
    return "stable"

趋势判断为什么要用均值而不是最后两个点?

最后两个点:
    排名 [10, 10, 10, 10, 10, 3]
    → 最后两个点是 10 和 3,判定"大幅上升"
    → 但其实只有最后一个点是异常值

分段均值:
    → 前 1/4 的均值 vs 后 1/3 的均值
    → 单点噪声被稀释,趋势更稳定

更精确的做法是线性回归。

把 (timestamp, rank) 拟合一条直线,斜率就是趋势强度

斜率 < -0.001  → 稳定上升
斜率 >  0.001  → 稳定下降
斜率 ≈ 0       → 平稳

优点:利用了所有数据点,比均值比较更准确

趋势数据的用途:

1. 图表展示
   返回 [{timestamp, rank}] 数组,前端画折线图 / 迷你趋势线

2. 热度判断
   "最近 1 小时排名上升超过 20 位" → 标记为"飙升中"

3. 推荐加权
   上升趋势的文章在推荐流里获得额外曝光

4. 预警
   连续下跌 → 可能内容质量下滑 → 通知作者

计算趋势应该预聚合,不要在读接口里现算。

实时计算:每次请求都要拉全部历史记录 + 排序 + 求均值
预聚合:定时任务(每 5 分钟)算好一次,存进一个 Hash
        rank:trend:article:123 → {current, best, trend, points}

读取就是一次 HGETALL,非常快

趋势接口的响应设计:

GET /api/articles/123/rank-trend?hours=24

{
  "article_id": 123,
  "current_rank": 5,
  "best_rank": 2,
  "worst_rank": 47,
  "trend": "rising",
  "points": [
    {"timestamp": 1710000000, "rank": 47},
    {"timestamp": 1710000600, "rank": 32},
    {"timestamp": 1710001200, "rank": 18}
  ]
}

points 的数量要控制。 24 小时每 5 分钟一个点是 288 个点,够画图了。全量返回会浪费带宽,前端通常只需要 50 个点左右——服务端做降采样:

if len(points) > 50:
    step = len(points) // 50
    points = points[::step]

实时推送

WebSocket 推送排名更新

WebSocket 是排行榜实时推送的标准方案:服务端保持长连接,排名一变就主动推给客户端。

class RankingPushServer:
    """排行榜 WebSocket 推送服务"""

    CHANNEL = "ranking:push"

    def __init__(self, redis_client):
        self.redis = redis_client
        self.connections = {}      # user_id → websocket
        self._lock = asyncio.Lock()

    async def register(self, user_id, websocket):
        """客户端连接时注册"""
        await websocket.accept()
        async with self._lock:
            self.connections[user_id] = websocket
        # 订阅 Redis 频道,把推送转发给对应客户端
        await self._forward_to_client(user_id, websocket)

    async def _forward_to_client(self, user_id, websocket):
        """订阅 Redis 频道,把消息推给客户端"""
        pubsub = self.redis.pubsub()
        await pubsub.subscribe(self.CHANNEL)
        async for message in pubsub.listen():
            if message["type"] != "message":
                continue
            payload = json.loads(message["data"])
            # 只推给关心这个榜单的客户端
            if payload.get("scope") not in (None, "global"):
                continue
            await websocket.send_text(json.dumps(payload))

    async def broadcast(self, payload):
        """向所有客户端广播"""
        message = json.dumps(payload)
        self.redis.publish(self.CHANNEL, message)

多实例部署时,Pub/Sub 负责跨实例转发。

实例 A 负责处理用户 1 的连接
实例 B 负责处理用户 2 的连接

用户 1 点赞 → 触发排行榜更新(发生在实例 B)
→ 实例 B 发布到 Redis 频道
→ 实例 A 订阅了这个频道 → 推给用户 1 ✅

如果要求”推送不丢”,Pub/Sub 不够,要用 Redis Stream。

Pub/Sub:   即发即弃,客户端断连期间的消息永久丢失
Stream:    消息保留在 Stream 里,客户端重连后可以补拉

用 Stream 做可靠推送:

# 生产者
redis.xadd("ranking:push:stream", payload)

# 消费者(每个实例消费自己关心的消息)
messages = redis.xreadgroup(group, consumer, {stream: ">"}, count=100, block=1000)
# 断线重连后可以读未确认的历史消息
pending = redis.xreadgroup(group, consumer, {stream: "0"})

推送的连接管理:

1. 心跳检测
   客户端每 30 秒发一个 ping,服务端 60 秒没收到就断开
   → 避免半开连接堆积

2. 断线重连
   客户端指数退避重连,重连后带上"最后收到的序号"
   → 服务端补发遗漏的消息

3. 连接数限制
   单个用户只保留一个连接,新连接踢掉旧的

WebSocket 的容量评估:

10,000 个在线用户 × 每秒 1 条推送 × 每条 200 字节
= 2 MB/s 的出站带宽

对推送服务来说,这是可以承受的。
真正的问题是推送频率——每秒 100 条就扛不住了。

所以必须做推送聚合和限频,见下面的三个优化。

前端实时更新

服务端推的是”排名变了”,前端要负责把它变成用户看得懂的界面。

class RankingClient {
  constructor(url) {
    this.ws = new WebSocket(url)
    this.items = []            // 当前榜单数据
    this.itemMap = new Map()   // article_id → item
    this.rankMap = new Map()   // article_id → 上次的排名

    this.ws.onmessage = (e) => this.handleMessage(JSON.parse(e.data))
    this.ws.onclose = () => this.reconnect()
  }

  handleMessage(payload) {
    if (payload.type === 'rank_update') {
      payload.changes.forEach(change => this.applyChange(change))
    }
    if (payload.type === 'full_refresh') {
      this.items = payload.items
      this.render()
    }
  }

  applyChange({ article_id, rank, like_count }) {
    const item = this.itemMap.get(article_id)
    if (!item) return

    const oldRank = this.rankMap.get(article_id)
    this.rankMap.set(article_id, rank)
    item.rank = rank
    item.like_count = like_count

    // 记录名次变化方向,供动画使用
    item.direction = oldRank > rank ? 'up' : (oldRank < rank ? 'down' : 'same')
    item.changed = oldRank !== undefined && oldRank !== rank
  }

  render() {
    // 按新排名重新排序
    this.items.sort((a, b) => a.rank - b.rank)
    // ... 更新 DOM
  }
}

前端的三个核心职责:

1. 排序
   收到新排名后重新排序整个列表
   → 只在"名次真的变了"时才重排,避免无谓的 DOM 操作

2. 动画标记
   记录每条的变化方向(up/down/same)和是否变化
   → 交给 CSS 做动画

3. 兜底对齐
   推送可能丢,最终要跟服务端对一次账
   → 定期拉一次完整榜单做全量替换

“只重排变化的条目”是性能关键。

全量重排(每次推送):
    100 条数据,每次推送都要重排 + 更新 DOM
    → 推送频率高时会有明显的卡顿

增量重排:
    只把名次变了的条目移到新位置
    → DOM 操作从 100 次降到 1~3 次

前端要有”静默期”机制。

连续收到 10 条推送 → 只渲染最后一条的结果
→ 用 requestAnimationFrame 或 setTimeout(…, 100) 合并

最终一致:前端要定期跟服务端对齐。

推送可能丢、可能乱序
→ 每 30 秒拉一次完整榜单
→ 全量替换本地数据
→ 推送只是"让体验变快",全量拉取才是"保证正确"

这个设计叫做推送加速 + 拉取兜底,是实时榜单的标准做法。

CSS 动画

排名变化的动画要做到”有变化才动”,而且不能打断用户的操作。

.rank-item {
  transition: transform 0.6s cubic-bezier(0.4, 0, 0.2, 1),
              background-color 0.6s ease;
  will-change: transform;
}

/* 排名上升 */
.rank-item.up {
  transform: translateY(-8px);
  background-color: rgba(52, 211, 153, 0.15);
}

/* 排名下降 */
.rank-item.down {
  transform: translateY(8px);
  background-color: rgba(239, 68, 68, 0.12);
}

/* 名次变化的徽标 */
.rank-badge {
  transition: opacity 0.4s ease, transform 0.4s ease;
}

.rank-badge.show {
  opacity: 1;
  transform: scale(1.1);
}

用 transform 而不是 top/margin 做位移。

top / margin:     触发重排(layout),每帧都要重新计算布局
transform:        只触发合成(composite),由 GPU 处理
→ 排行榜动画必须用 transform

will-change 要慎用。

will-change: transform  → 浏览器会为这个元素创建合成层
→ 元素太多时内存暴涨
→ 只给"正在动画"的元素加,动画结束后移除

动画要可关闭。

@media (prefers-reduced-motion: reduce) {
  .rank-item {
    transition: none;
    transform: none !important;
  }
}

前庭功能障碍的用户会因位移动画产生不适,这是无障碍的基本要求。

数字变化的动画(点赞数滚动)可以用 JS 实现:

function animateNumber(el, from, to, duration = 500) {
  const start = performance.now()
  function step(now) {
    const progress = Math.min((now - start) / duration, 1)
    // easeOutCubic
    const eased = 1 - Math.pow(1 - progress, 3)
    el.textContent = Math.round(from + (to - from) * eased)
    if (progress < 1) requestAnimationFrame(step)
  }
  requestAnimationFrame(step)
}

数字滚动动画要做”去抖”。

连续收到 10 条推送,数字从 100 滚到 110
→ 不要从 100 开始滚 10 次
→ 从"当前显示的数字"滚到"最新数字"

动画期间的新值应该覆盖而不是叠加。


性能优化

优化 1:批量推送

逐条推送会产生大量小消息,批量推送把它们合成一条。

def build_batch_push(changes, window=1.0):
    """把窗口内的排名变化合并成一条推送"""
    return {
        "type": "rank_update",
        "timestamp": int(time.time()),
        "count": len(changes),
        "changes": changes,
    }

服务端的批量推送器:

class BatchPusher:
    """在固定窗口内累积变化,统一推送"""

    def __init__(self, interval=1.0):
        self.interval = interval
        self.pending = {}
        self._lock = threading.Lock()
        self._stop = threading.Event()
        self._thread = None

    def add_change(self, article_id, rank, like_count):
        with self._lock:
            self.pending[article_id] = {"rank": rank, "like_count": like_count}

    def _run(self):
        while not self._stop.wait(self.interval):
            self.push()

    def push(self):
        with self._lock:
            changes = self.pending
            self.pending = {}
        if not changes:
            return

        payload = {
            "type": "rank_update",
            "count": len(changes),
            "changes": [
                {"article_id": aid, **data} for aid, data in changes.items()
            ],
        }
        self.redis.publish("ranking:push", json.dumps(payload))

批量推送把消息数降了一个数量级。

逐条推送:
    100 条变化 → 100 条 WebSocket 消息 → 100 次序列化 + 100 次 send

批量推送(1 秒窗口):
    100 条变化 → 1 条消息 → 1 次序列化 + 1 次 send

批量窗口怎么选?

窗口消息数延迟适用
无批量最高最低变化极少
500ms较高低中等规模
1s低中通用选择
5s最低高大规模、容忍延迟

同一个文章在同一窗口内只推最后一次。

pending 是以 article_id 为键的字典,天然实现了”合并”——一个文章在窗口内变化 10 次,也只会推一次。

批量推送的边界:单条消息不能太大。

1000 条变化 × 100 字节 = 100 KB
→ 单条 WebSocket 消息建议不超过 64 KB
→ 超过就拆成多条发送

优化 2:只推送变化

批量推送解决了”消息条数”,但没有解决”每条消息的内容”。很多推送里包含客户端其实不需要的信息。

完整推送:
{
  "type": "rank_update",
  "count": 100,
  "changes": [
    {"article_id": 1, "rank": 5, "like_count": 1010, "title": "创业者的一天", "author": "张三", "avatar": "https://..."},
    ... 100 条
  ]
}

客户端其实只需要”名次”和”数量”,其他字段它已经有了。

精简推送:
{
  "type": "rank_update",
  "count": 100,
  "changes": [
    {"article_id": 1, "rank": 5, "like_count": 1010},
    ... 100 条
  ]
}

字段名还能再缩短。

{"a": 1, "r": 5, "c": 1010}     ← 省掉一半字节

代价是可读性变差,通常只在极端带宽压力下才这么做。

更重要的是”只推送排名真正变了的条目”。

筛选逻辑:
    排名没变 → 不推(客户端的显示不需要变)
    排名变了 → 推
    新进入榜单 → 推
    掉出榜单 → 推
class ChangeDetector:
    """对比新旧榜单,只保留真正变化的部分"""

    def __init__(self):
        self.last_snapshot = {}    # article_id → rank

    def detect(self, new_snapshot):
        """返回变化列表"""
        changes = []
        old = self.last_snapshot

        for article_id, (rank, like_count) in new_snapshot.items():
            old_rank = old.get(article_id)
            if old_rank is None:
                # 新进入榜单
                changes.append({"article_id": article_id, "rank": rank,
                                "like_count": like_count, "type": "enter"})
            elif old_rank != rank:
                changes.append({"article_id": article_id, "rank": rank,
                                "like_count": like_count, "type": "move",
                                "from": old_rank})
            # 排名没变 → 不推

        for article_id in old:
            if article_id not in new_snapshot:
                changes.append({"article_id": article_id, "type": "leave"})

        self.last_snapshot = {
            aid: rank for aid, (rank, _) in new_snapshot.items()
        }
        return changes

“排名没变就不推”能砍掉大部分消息。

爆款文章每秒 100 个赞,但排名可能一直是第 1
→ 逐条推送:100 条/秒
→ 只推变化:0 条/秒 ✅

但要注意”名次没变但点赞数变了”的情况。

文章的点赞数从 1010 变成 1020,但排名一直是第 5
→ 客户端的数字要不要更新?

产品上通常要更新(用户能看到数字在涨)。所以有两个粒度可选:

粗粒度:排名或点赞数变了就推
细粒度:只推排名变化,点赞数靠定时全量刷新

“只推变化”的另一个前提是服务端要维护快照。

快照存在内存里 → 多实例部署时每个实例的快照不同
→ 推送内容会不一致

解决办法是用 Redis 存一份共享快照,或者保证只有专门的推送服务实例做这件事。

优化 3:分级推送

不是所有用户都需要同样”新鲜”的排行榜。分级推送按重要性分配推送资源。

分级规则(示例):

P0(立即推送):
    用户的关注对象 / 好友
    自己发布的文章
    → 涉及个人情感,延迟不可接受

P1(1 秒内):
    Top 10 的名次变化
    → 榜单头部变化最敏感

P2(5 秒内):
    Top 100 的名次变化
    → 普通用户的关注范围

P3(30 秒内 / 不推送):
    Top 100 之外的
    → 用户大概率看不到这一页
class TieredPusher:
    """分级推送:不同重要度的变更走不同的推送通道"""

    TIERS = [
        # (最大名次, 推送间隔秒数, 优先级)
        (10,   1.0,  "P1"),
        (100,  5.0,  "P2"),
        (1000, 30.0, "P3"),
    ]

    def __init__(self, redis_client):
        self.redis = redis_client
        self.tiers = {name: [] for _, _, name in self.TIERS}
        self._lock = threading.Lock()

    def add(self, article_id, rank, like_count, is_followed=False):
        """按名次和关注关系决定推送优先级"""
        if is_followed:
            tier = "P0"
        else:
            tier = self._tier_for(rank)

        with self._lock:
            self.tiers[tier].append({
                "article_id": article_id,
                "rank": rank,
                "like_count": like_count,
            })

    def _tier_for(self, rank):
        for max_rank, _, name in self.TIERS:
            if rank <= max_rank:
                return name
        return "P3"

    def flush(self):
        """按优先级依次推送"""
        with self._lock:
            snapshot = dict(self.tiers)
            for name in self.tiers:
                self.tiers[name] = []

        for name in ("P0", "P1", "P2", "P3"):
            changes = snapshot.get(name) or []
            if not changes:
                continue
            self.redis.publish(
                f"ranking:push:{name}",
                json.dumps({"type": "rank_update", "tier": name,
                            "count": len(changes), "changes": changes}),
            )

客户端要订阅不同优先级的频道,但可以合并渲染。

P0 频道:收到就立刻渲染
P1/P2 频道:收到后放进队列,在下一个动画帧统一渲染
P3 频道:只更新数据,不触发重排(用户翻到那一页时再看)

分级的收益:

不分级:
    所有变化都走同一个通道 → 消息量最大,低价值变化挤占带宽

分级后:
    P0/P1 变化量通常只占总变化量的 5%
    → 95% 的变化被降级处理
    → 高优先级变化几乎瞬间到达

分级的代价是实现复杂度上升。

- 要维护多套订阅
- 要处理不同优先级的乱序
- 要定义清楚每个优先级的"间隔"和"最大延迟"

分级规则应该配一个后台管理界面。

运营可以调整:
- Top N 的分界(N 不是固定的)
- 各个级别的推送间隔
- 哪些用户走 P0(比如 VIP)

最实用的分级维度其实只有两个:名次 + 是否关注。

关注对象 → P0
Top 10   → P1
Top 100  → P2
其余     → P3

别把分级做得太细。 超过三档之后,运维复杂度和收益就不成正比了。


课后练习

练习 1

如何实现”预测排名”功能?

排行榜预测算法

解题思路:

这道题问的是『还没发生的结果怎么提前算出来』,核心是用历史趋势外推。

详细步骤:

方案:基于趋势预测

实现步骤:

  1. 指标采集:定时(如每 5 分钟)统计每篇文章最近窗口的点赞增量
  2. 趋势计算:线性回归斜率或滑动平均,得到增长速度
  3. 预测:score = 当前值 + 速度 × 预测时间窗口
  4. 写入独立 key:rank:predicted,与真实榜分开
  5. 定期淘汰:超过预测时长的条目自动清理

注意:

  • 预测值必须与真实值分开存储或明确标记,不能混入真实排行榜
  • 冷启动文章样本不足,预测不可靠,应过滤掉

最终答案:

基于趋势预测:为每篇文章(和用户)维护近期点赞的增长速率(如最近 1 小时的斜率),用线性外推或滑动平均预测未来一段时间的点赞数,再把预测值与当前值组合成一个『预测分数』写进独立的 ZSET(用单独的 key 或前缀区分),查询时按预测分数排序即可。预测值要标记为预测值并设置过期,避免和真实值混淆。

练习 2

如何实现”排名对比”功能?

排行榜对比数据分析

解题思路:

这道题问的是『两个人的排名差距怎么展示』,核心是要有历史排名的存储。

详细步骤:

方案:记录多个时间点的排名

实现步骤:

  1. 定时任务(每 5~10 分钟)把当前排名写入快照:ZADD rank:history:20261022 {score} {uid}
  2. 快照 key 按时间命名,便于按时间片查询和清理
  3. 对比:取两个时间片的 ZREVRANK 相减,得到名次变化
  4. 展示:结合分数变化,生成『上升/下降 N 名』的文案

注意:

  • 快照频率是成本与精度的权衡,频率越高存储越大
  • 快照只存用户维度的名次,避免数据量爆炸;可只对活跃用户采样

最终答案:

记录多个时间点的排名快照:为每个用户(或文章)定期把当前名次写入一个时序存储(Redis ZSET 快照 rank:history:{yyyyMMddHH},或时序数据库),展示时取出两个时间点的快照做差值,并结合当时的分数给出『上升 N 名』『下降 N 名』。快照按时间分片写入,查询只扫需要的两个时间片。

练习 3

如何实现”排名预警”功能?

排行榜预警监控

解题思路:

这道题问的是『排名掉下去要能提前知道』,核心是要持续比较当前名次与名次阈值。

详细步骤:

方案:监控排名变化

实现步骤:

  1. 配置阈值:每个用户可设置自己的名次预警线
  2. 定时比较:每 1~5 分钟取用户当前排名与阈值比较
  3. 写预警名单:命中阈值的用户写入 rank:alert 并去重(同一次事件不重复通知)
  4. 推送通知:消费预警名单,走 Push/站内信
  5. 恢复后清理:名次回升后从名单中移除

注意:

  • 通知要有冷却时间,避免反复掉榜反复推送
  • 排名查询要用 ZREVRANK,注意深排名查询的成本

最终答案:

监控排名变化:先为每个用户设定名次阈值(如跌出前 1000 名),用定时任务周期性地把当前排名与阈值比较;对接近阈值的用户写入『预警名单』(Redis ZSET 或 Set),再通过推送(站内信/Push/邮件)通知。关键是把比较动作从请求路径挪到定时任务,避免每次排名查询都做判断。

练习 4

如何实现”排名徽章”功能?

排行榜游戏化徽章

解题思路:

这道题问的是把名次变成可视化的成就标签,核心是『档位划分 + 徽章授予』。

详细步骤:

方案:根据排名授予徽章

实现步骤:

  1. 定义档位表:段位、名称、图标、名次区间、颜色
  2. 定时任务:取用户当前排名,与档位表比对
  3. 授予与回收:Hash 记录 badge:{uid} = {level, granted_at}
  4. 展示:接口返回徽章信息,前端渲染
  5. 段位重算:档位规则变更时跑一次全量重算任务

注意:

  • 徽章是『曾经达到』还是『当前持有』,语义要明确(建议同时记录历史)
  • 徽章授予是低频写操作,注意批量任务的限速

最终答案:

根据排名授予徽章:预先定义若干档位(如前 10 名为『钻石』、前 100 为『铂金』、前 1000 为『黄金』),用定时任务读取用户的当前名次,落到哪个档位就授予对应徽章;徽章用 Redis Hash 存储(badge:{uid}),同时记录授予时间以便展示和后续回收。档位边界变化时要有重算逻辑。

练习 5

如何实现”排名分享”功能?

排行榜社交分享

解题思路:

这道题问的是怎么把排名做成可传播的卡片,核心是『服务端渲染图片 + 带签名的分享链接』。

详细步骤:

方案:生成排名分享卡片

实现步骤:

  1. 取数据:当前名次(ZREVRANK)、分数(ZSCORE)、头像昵称
  2. 渲染:前端 Canvas 绘制或服务端无头浏览器截图
  3. 存储:图片上传对象存储,得到可访问 URL
  4. 分享链接:落地页链接携带 uid + 签名参数
  5. 防刷:链接加时效与签名,落地页做一次校验

注意:

  • 排名是时效数据,卡片上要标注『截至 xx:xx』
  • 分享出去的图片要脱敏,避免暴露用户 ID 等信息

最终答案:

生成排名分享卡片:服务端根据用户当前名次、分数、头像等信息渲染成图片(前端 Canvas 模板或服务端截图服务),上传到对象存储拿到 URL,再生成带参数的分享链接(指向落地页而非直接指向图片)。落地页要带签名或短时效校验,避免被恶意篡改或刷量;卡片上还要标注数据截止时间。


思考题

  1. 如何实现”跨天”的排名统计(比如从昨天 23:00 到今天 01:00)?

  2. 如何处理”并列排名”(分数相同的文章)?

  3. 如何实现”排名预测”的准确度评估?

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

发现内容有问题?

告诉我们哪里需要改进。