实时排行
实现了基础排行榜后,产品经理又提出了新要求:
【需求文档】实时排行榜
功能 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
如何实现”预测排名”功能?
解题思路:
这道题问的是『还没发生的结果怎么提前算出来』,核心是用历史趋势外推。
详细步骤:
方案:基于趋势预测
实现步骤:
- 指标采集:定时(如每 5 分钟)统计每篇文章最近窗口的点赞增量
- 趋势计算:线性回归斜率或滑动平均,得到增长速度
- 预测:score = 当前值 + 速度 × 预测时间窗口
- 写入独立 key:
rank:predicted,与真实榜分开 - 定期淘汰:超过预测时长的条目自动清理
注意:
- 预测值必须与真实值分开存储或明确标记,不能混入真实排行榜
- 冷启动文章样本不足,预测不可靠,应过滤掉
最终答案:
基于趋势预测:为每篇文章(和用户)维护近期点赞的增长速率(如最近 1 小时的斜率),用线性外推或滑动平均预测未来一段时间的点赞数,再把预测值与当前值组合成一个『预测分数』写进独立的 ZSET(用单独的 key 或前缀区分),查询时按预测分数排序即可。预测值要标记为预测值并设置过期,避免和真实值混淆。
练习 2
如何实现”排名对比”功能?
解题思路:
这道题问的是『两个人的排名差距怎么展示』,核心是要有历史排名的存储。
详细步骤:
方案:记录多个时间点的排名
实现步骤:
- 定时任务(每 5~10 分钟)把当前排名写入快照:
ZADD rank:history:20261022 {score} {uid} - 快照 key 按时间命名,便于按时间片查询和清理
- 对比:取两个时间片的 ZREVRANK 相减,得到名次变化
- 展示:结合分数变化,生成『上升/下降 N 名』的文案
注意:
- 快照频率是成本与精度的权衡,频率越高存储越大
- 快照只存用户维度的名次,避免数据量爆炸;可只对活跃用户采样
最终答案:
记录多个时间点的排名快照:为每个用户(或文章)定期把当前名次写入一个时序存储(Redis ZSET 快照 rank:history:{yyyyMMddHH},或时序数据库),展示时取出两个时间点的快照做差值,并结合当时的分数给出『上升 N 名』『下降 N 名』。快照按时间分片写入,查询只扫需要的两个时间片。
练习 3
如何实现”排名预警”功能?
解题思路:
这道题问的是『排名掉下去要能提前知道』,核心是要持续比较当前名次与名次阈值。
详细步骤:
方案:监控排名变化
实现步骤:
- 配置阈值:每个用户可设置自己的名次预警线
- 定时比较:每 1~5 分钟取用户当前排名与阈值比较
- 写预警名单:命中阈值的用户写入
rank:alert并去重(同一次事件不重复通知) - 推送通知:消费预警名单,走 Push/站内信
- 恢复后清理:名次回升后从名单中移除
注意:
- 通知要有冷却时间,避免反复掉榜反复推送
- 排名查询要用 ZREVRANK,注意深排名查询的成本
最终答案:
监控排名变化:先为每个用户设定名次阈值(如跌出前 1000 名),用定时任务周期性地把当前排名与阈值比较;对接近阈值的用户写入『预警名单』(Redis ZSET 或 Set),再通过推送(站内信/Push/邮件)通知。关键是把比较动作从请求路径挪到定时任务,避免每次排名查询都做判断。
练习 4
如何实现”排名徽章”功能?
解题思路:
这道题问的是把名次变成可视化的成就标签,核心是『档位划分 + 徽章授予』。
详细步骤:
方案:根据排名授予徽章
实现步骤:
- 定义档位表:段位、名称、图标、名次区间、颜色
- 定时任务:取用户当前排名,与档位表比对
- 授予与回收:Hash 记录
badge:{uid} = {level, granted_at} - 展示:接口返回徽章信息,前端渲染
- 段位重算:档位规则变更时跑一次全量重算任务
注意:
- 徽章是『曾经达到』还是『当前持有』,语义要明确(建议同时记录历史)
- 徽章授予是低频写操作,注意批量任务的限速
最终答案:
根据排名授予徽章:预先定义若干档位(如前 10 名为『钻石』、前 100 为『铂金』、前 1000 为『黄金』),用定时任务读取用户的当前名次,落到哪个档位就授予对应徽章;徽章用 Redis Hash 存储(badge:{uid}),同时记录授予时间以便展示和后续回收。档位边界变化时要有重算逻辑。
练习 5
如何实现”排名分享”功能?
解题思路:
这道题问的是怎么把排名做成可传播的卡片,核心是『服务端渲染图片 + 带签名的分享链接』。
详细步骤:
方案:生成排名分享卡片
实现步骤:
- 取数据:当前名次(ZREVRANK)、分数(ZSCORE)、头像昵称
- 渲染:前端 Canvas 绘制或服务端无头浏览器截图
- 存储:图片上传对象存储,得到可访问 URL
- 分享链接:落地页链接携带 uid + 签名参数
- 防刷:链接加时效与签名,落地页做一次校验
注意:
- 排名是时效数据,卡片上要标注『截至 xx:xx』
- 分享出去的图片要脱敏,避免暴露用户 ID 等信息
最终答案:
生成排名分享卡片:服务端根据用户当前名次、分数、头像等信息渲染成图片(前端 Canvas 模板或服务端截图服务),上传到对象存储拿到 URL,再生成带参数的分享链接(指向落地页而非直接指向图片)。落地页要带签名或短时效校验,避免被恶意篡改或刷量;卡片上还要标注数据截止时间。
-
如何实现”跨天”的排名统计(比如从昨天 23:00 到今天 01:00)?
-
如何处理”并列排名”(分数相同的文章)?
-
如何实现”排名预测”的准确度评估?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
