ZSET 数据结构
产品经理又来了:
【需求文档】排行榜功能
功能 1:热门文章榜
- 按点赞数排序
- Top 100
- 实时更新
功能 2:24 小时热榜
- 最近 24 小时发布文章
- 按点赞数排序
功能 3:本周热榜
- 本周发布文章
- 按点赞数排序
功能 4:作者榜
- 按文章获赞总数
- Top 100 作者
这就是排行榜需求。
什么是 ZSET?
Redis Sorted Set(有序集合):
- 类似 Set,不允许重复元素
- 每个元素关联一个分数(score)
- 按分数自动排序
- 支持范围查询
示例:
ZADD ranking 100 "article:1"
ZADD ranking 200 "article:2"
ZADD ranking 150 "article:3"
自动排序:
article:2 (200)
article:3 (150)
article:1 (100)
ZSET 特性
特性 1:自动排序
- 按分数从小到大排序
- 分数相同时按字典序
- 支持倒序查询
特性 2:唯一性
- 元素唯一
- 重复添加会更新分数
特性 3:高性能
- O(log N) 添加/删除
- O(log N) 范围查询
- O(1) 获取排名
特性 4:丰富操作
- ZADD:添加/更新
- ZINCRBY:增加分数
- ZRANGE/ZREVRANGE:范围查询
- ZRANK/ZREVRANK:获取排名
- ZCOUNT:统计范围内的元素数量
点赞排行榜
排行榜的核心数据结构是一个 ZSET:member 是文章 ID,score 是点赞数。
# 初始化排行榜
ZADD ranking:articles:hot 100 "article:1"
ZADD ranking:articles:hot 200 "article:2"
ZADD ranking:articles:hot 150 "article:3"
# 取 Top 10(按分数从高到低)
ZREVRANGE ranking:articles:hot 0 9 WITHSCORES
1) "article:2"
2) "200"
3) "article:3"
4) "150"
5) "article:1"
6) "100"
为什么用 ZSET 而不是别的结构?
| 结构 | 排序 | 去重 | 取 Top N | 增量更新 |
|---|---|---|---|---|
| List | ❌ | ❌ | O(N) | O(1) |
| Set | ❌ | ✅ | O(N) | O(1) |
| Hash | ❌ | ✅ | O(N) | O(1) |
| ZSET | ✅ | ✅ | O(log N + M) | O(log N) |
ZSET 同时满足了排行榜的全部需求。
Python 实现:
class RankingService:
"""基于 ZSET 的排行榜服务"""
HOT_KEY = "ranking:articles:hot"
def __init__(self, redis_client, top_n=100):
self.redis = redis_client
self.top_n = top_n
def update_score(self, article_id, delta):
"""点赞后更新排行榜分数"""
return self.redis.zincrby(self.HOT_KEY, delta, str(article_id))
def set_score(self, article_id, score):
"""直接设置分数(初始化或修正用)"""
self.redis.zadd(self.HOT_KEY, {str(article_id): score})
def get_top(self, limit=None):
"""取排行榜(按分数倒序)"""
limit = limit or self.top_n
members = self.redis.zrevrange(
self.HOT_KEY, 0, limit - 1, withscores=True
)
return [
{"article_id": int(m), "rank": i + 1, "like_count": int(s)}
for i, (m, s) in enumerate(members)
]
def get_rank(self, article_id):
"""查询某篇文章的排名(从 1 开始)"""
rank = self.redis.zrevrank(self.HOT_KEY, str(article_id))
if rank is None:
return None
return {"article_id": article_id, "rank": rank + 1}
def get_score(self, article_id):
"""查询某篇文章的分数"""
score = self.redis.zscore(self.HOT_KEY, str(article_id))
return int(score) if score is not None else 0
ZINCRBY 是排行榜的核心命令。
ZINCRBY ranking:articles:hot 1 "article:123"
"101"
它原子地把分数加 1,并返回加之后的分数。这意味着点赞接口可以顺手更新排行榜:
def like(self, article_id, user_id):
count = redis.incr(f"article:{article_id}:like_count")
redis.zincrby("ranking:articles:hot", 1, str(article_id))
return count
但这一步不是免费的。 每次点赞都更新排行榜,会让写路径多一次 ZINCRBY,而且所有点赞同一篇文章的请求都会竞争同一个 ZSET 节点——这正是《分片计数》要解决的问题。更省的做法是延迟更新,见《实时排行》一章。
分数相同时的排序规则。
ZSET 分数相同时,按 member 的字典序排序:
ZADD ranking 100 "article:10"
ZADD ranking 100 "article:9"
ZREVRANGE ranking 0 -1
→ "article:9" 在 "article:10" 前面
(字典序:'9' > '1')
这会造成一个反直觉的结果:article:10 排在 article:9 后面。
如果业务上希望”先发布的排前面”(或反过来),可以把发布时间编码进分数:
score = like_count * 10^12 + (MAX_TIMESTAMP - published_at)
这样分数相同时就自动按发布时间排了。代价是分数变大、精度处理更复杂。
取 Top N 的复杂度是 O(log N + M),N 是集合大小,M 是取出的数量。取 Top 100 很快,取 Top 10000 就开始变慢——这是《分页优化》一章要解决的问题。
实时更新排行榜
“实时更新”指的是:点赞之后,排行榜立刻反映最新排名,而不是等一个定时任务。
def get_top_realtime(self, limit=100):
"""实时排行榜:读的时候直接算排名"""
members = self.redis.zrevrange(
self.HOT_KEY, 0, limit - 1, withscores=True
)
return [
{"article_id": int(m), "rank": i + 1, "like_count": int(s)}
for i, (m, s) in enumerate(members)
]
实时更新的”实时”来自 ZSET 的自动排序。
ZINCRBY ranking:articles:hot 1 "article:3"
→ article:3 的分数变成 151
→ 它自动从第 3 名升到第 2 名(因为 151 > 150)
→ 不需要任何"重排"操作
这是 ZSET 相对于”应用层维护有序列表”的最大优势。
如果用 List 自己维护排名,每次点赞都要重新排序或局部调整,复杂度是 O(N)。ZSET 是 O(log N),而且是服务端的原子操作。
实时更新的代价是读的时候要算排名。
ZREVRANGE 返回的顺序就是排名顺序,所以排名是”读出来时”算的,不是存着的。这带来两个问题:
1. 分页时排名会漂移。
用户 A 打开第 1 页,看到第 1~20 名
此时有人点赞,第 21 名冲到了第 5 名
用户 A 翻到第 2 页,原本的第 21~40 名现在变成了第 22~41 名
→ 第 21 名被重复看到,或者有人被跳过
2. 查询”我的排名”要单独一次调用。
ZREVRANK ranking:articles:hot "article:123"
(integer) 4
ZREVRANK 是 O(log N),很便宜,可以和 Top N 查询放在同一个 Pipeline 里。
一个更实用的做法:把排名快照缓存起来。
def get_top_with_rank(self, limit=100):
"""一次拿到 Top N 和指定文章的排名"""
pipe = self.redis.pipeline()
pipe.zrevrange(self.HOT_KEY, 0, limit - 1, withscores=True)
pipe.zrevrank(self.HOT_KEY, str(self.my_article_id))
results = pipe.execute()
members, my_rank = results
return {
"top": [...],
"my_rank": my_rank + 1 if my_rank is not None else None,
}
为什么”实时”排行榜通常要做一点延迟?
每次点赞都立刻推送给所有在线用户:
爆款文章每秒 100 个赞
→ 100 次推送/秒 × 在线用户数 = 消息风暴
实际产品里,排行榜通常有 1~5 秒的刷新间隔——用户感知不到,但把推送量降低了几个数量级。这个策略见《实时排行》一章。
24 小时热榜
“24 小时热榜”要按最近 24 小时内的点赞数排序,而不是历史总点赞数。
方案一:用滚动窗口的 ZSET(推荐)
# 每小时一个 ZSET,key 里带小时数
# ranking:hot:2024101514 → 2024-10-15 14 点这一小时内的点赞
def like_with_hourly_bucket(self, article_id, user_id):
"""点赞时同时更新当前小时桶"""
count = redis.incr(f"article:{article_id}:like_count")
hour_key = f"ranking:hot:{time.strftime('%Y%m%d%H')}"
redis.zincrby(hour_key, 1, str(article_id))
return count
def get_24h_hot(self, limit=100):
"""24 小时热榜:合并最近 24 个小时桶"""
buckets = [
f"ranking:hot:{time.strftime('%Y%m%d%H', time.localtime(time.time() - i * 3600))}"
for i in range(24)
]
pipe = self.redis.pipeline()
for key in buckets:
pipe.zrange(key, 0, -1, withscores=True)
results = pipe.execute()
# 合并所有小时的分数
totals = defaultdict(int)
for members in results:
for member, score in members:
totals[member] += int(score)
ranked = sorted(totals.items(), key=lambda x: x[1], reverse=True)
return [
{"article_id": int(m), "like_count": s}
for m, s in ranked[:limit]
]
用 ZUNIONSTORE 可以让服务端直接完成合并,更快。
ZUNIONSTORE ranking:hot:24h <24 个 key> AGGREGATE SUM
ZREVRANGE ranking:hot:24h 0 99 WITHSCORES
每个小时桶要设置 TTL,否则会无限增长。
redis.expire(hour_key, 48 * 3600) # 保留 48 小时
方案二:用带时间戳的 ZSET + 范围查询
# 单一 ZSET,score 是点赞时间戳
ZADD ranking:hot:events <timestamp> "<article_id>:<unique_seq>"
查询时先按时间范围取出所有记录,再按 article_id 聚合。这个方案的问题是”同一文章在同一小时内被赞多次”会产生多条记录,聚合成本高。
方案一(小时桶)在工程上更实用,因为它天然做了预聚合。
方案三:Redis Stream + 时间窗口
用 Stream 记录每一次点赞事件,消费端按时间窗口聚合。优点是数据可回溯、可以算任意窗口;缺点是复杂度高、内存开销大。
三种方案的取舍:
| 方案 | 查询性能 | 内存 | 实现复杂度 | 灵活度 |
|---|---|---|---|---|
| 小时桶 | O(24 + N) | 低 | 低 | 只能查整小时窗口 |
| 时间戳 ZSET | O(窗口内事件数) | 中 | 中 | 任意窗口 |
| Stream | 中 | 高 | 高 | 任意窗口 + 可回溯 |
如果只需要”最近 24 小时”和”本周”这两种固定窗口,小时桶是最优解。
小时桶的边界问题:
现在是 15:30,"最近 24 小时"应该是
昨天 16:00 ~ 今天 15:30
但小时桶只能给出
昨天 15:00 ~ 今天 14:00(整小时对齐)
误差最多 1 小时。对热榜这种场景通常可以接受,但不能声称”精确的最近 24 小时”。
本周热榜
“本周热榜”和 24 小时热榜是同一套机制的另一个窗口。
def get_weekly_hot(self, limit=100):
"""本周热榜:合并本周所有小时桶(或用日桶)"""
# 按天分桶更省事:每天一个 ZSET
days = 7
buckets = [
f"ranking:hot:day:{time.strftime('%Y%m%d', time.localtime(time.time() - i * 86400))}"
for i in range(days)
]
...
周榜用”日桶”而不是”小时桶”。
24 小时热榜 → 小时桶(24 个)
本周热榜 → 日桶(7 个)
理由:
- 窗口越大,桶的粒度可以越粗
- 日桶的 key 数量少得多,查询更快
- 日桶配合 TTL 可以长期保留,做成"日榜历史"
日桶要设置更长的 TTL。
redis.expire(day_key, 30 * 86400) # 保留 30 天
这样既能算本周热榜,也能算”昨天的热榜”、“上周热榜”,还可以画出历史趋势。
“本周”的起始日要定义清楚。
常见定义:
- 自然周:周一 00:00 到周日 23:59
- 滚动 7 天:过去 168 小时
两者结果不一样,产品需求要说清楚。
def get_week_hot(self, week_start="monday", limit=100):
"""自然周热榜:从本周一 00:00 开始"""
now = time.localtime()
# 计算本周一 00:00 的时间戳
days_since_monday = (now.tm_wday - 0) % 7
monday = time.mktime((
now.tm_year, now.tm_mon, now.tm_mday - days_since_monday,
0, 0, 0, 0, 0, -1
))
# 然后按天取桶
...
桶的 key 设计决定了查询的灵活性。
ranking:hot:hour:2024101514
ranking:hot:day:20241015
ranking:hot:week:2024w42 ← 预聚合的周桶
加上周桶的好处:
本周热榜查询 = 读 1 个桶
不需要合并 7 个日桶
周桶在每周一凌晨定时生成(把上周 7 个日桶合并),或者在每次查询时实时合并(更实时但更慢)。
按文章获赞总数
作者榜和文章榜的区别在于:统计的对象不同,但数据结构完全一样。
文章榜:member = article_id,score = 文章的点赞数
作者榜:member = author_id,score = 作者所有文章的点赞总数
def like_with_author_ranking(self, article_id, author_id, user_id):
"""点赞时同时更新文章榜和作者榜"""
pipe = self.redis.pipeline()
pipe.incr(f"article:{article_id}:like_count")
pipe.zincrby("ranking:articles:hot", 1, str(article_id))
pipe.zincrby("ranking:authors:hot", 1, str(author_id))
pipe.execute()
用 Pipeline 把三次更新合并成一次往返。
逐条执行:3 次往返 ≈ 0.9ms
Pipeline: 1 次往返 ≈ 0.3ms
作者榜的一个难点:作者的历史获赞数。
新作者一开始是 0,每次被点赞就 +1,这个逻辑本身没问题。但如果要做”作者总获赞”(包括历史文章、数据迁移之前的赞),需要初始化:
# 初始化:把数据库里的历史获赞数灌进作者榜
def init_author_ranking(self, db):
rows = db.query(
"SELECT author_id, SUM(like_count) AS total "
"FROM articles GROUP BY author_id"
)
pipe = self.redis.pipeline()
for row in rows:
pipe.zadd("ranking:authors:hot", {str(row["author_id"]): row["total"]})
pipe.execute()
ZINCRBY 只能做增量,作者榜的历史数据必须从数据库灌。
作者榜的另一个问题:一个作者有多篇文章时,计数是分散的。
作者 A 有 100 篇文章,每篇 10 个赞
→ 作者榜的分数应该是 1000
→ 但如果点赞时只更新了当前文章的作者计数,中间可能有偏差
关键的一致性要求:作者榜的分数必须等于”该作者所有文章的点赞数之和”。
# 一致性校验(对账任务)
for author_id, score in redis.zrange("ranking:authors:hot", 0, -1, withscores=True):
real = db.query(
"SELECT SUM(like_count) AS total FROM articles WHERE author_id = %s",
(author_id,)
)[0]["total"] or 0
if int(score) != real:
# 修复
redis.zadd("ranking:authors:hot", {author_id: real})
作者榜通常变化比文章榜慢。
文章榜每分钟可能有几百次变动,作者榜可能只有几十次。所以作者榜更适合用”定时聚合”而不是”实时更新”:
每 5 分钟跑一次聚合任务:
从数据库按作者分组求和 → 重建作者榜
用 ZREMRANGEBYRANK 全删再重建更简单,也避免了增量更新的累积误差。
优化 1:限制排行榜大小
排行榜只需要 Top N,但 ZSET 里存了所有文章。随着文章数增长,ZSET 会越来越大。
没有限制:
ZSET 里有 100 万篇文章
ZREVRANGE 取 Top 100 → O(log N + 100),其实很快
但:
- 内存占用:100 万 × ~60 字节 = 60 MB
- 每次 ZINCRBY 都要维护跳表
- 尾部的文章几乎不可能进 Top 100,却一直在消耗资源
限制大小的做法:用 ZREMRANGEBYRANK 裁剪尾部。
def update_score_with_limit(self, article_id, delta, top_n=1000):
"""更新分数后裁剪,只保留前 top_n 名"""
key = self.HOT_KEY
pipe = self.redis.pipeline()
pipe.zincrby(key, delta, str(article_id))
# 保留前 top_n 个,删掉其余的
pipe.zremrangebyrank(key, 0, -(top_n + 1))
pipe.execute()
裁剪的阈值要比展示的 Top N 大一些。
展示 Top 100 → 裁剪保留 Top 1000
→ 留出余量,被裁掉的文章还能通过"上升"重新进入榜单
→ 避免"第 1001 名刚刚挤进前 1000 却被立刻裁掉"的抖动
但裁剪会带来一个副作用。
文章 X 掉到第 1001 名 → 被裁掉
→ 它在 ZSET 里不存在了
→ ZREVRANK 查它 → nil(查不到排名)
→ 下次它获得点赞 → ZINCRBY → 分数从 0 开始 ❌
被裁掉的文章再获得点赞时,分数会丢失。
解决办法是裁剪时把分数记录到别处:
方案 A:单独维护一个完整的计数 Hash
ranking:articles:counts → article_id → 真实点赞数
ZSET 只用于排名,分数从 Hash 同步
方案 B:裁剪时把分数转移到"候选池"
ranking:articles:candidates → 保存被裁掉文章的分数
重新上榜时先从候选池恢复分数
方案 C:接受这个误差
热榜本来就是"近期热门",老文章重新爆火是长尾场景
大多数内容平台选方案 C 或 A。 方案 A 的代价是每次点赞要多更新一个 Hash,但作者的原始点赞数本来就在 article:{id}:like_count 里,所以其实不需要额外的 Hash——重新上榜时用那个 key 恢复分数就行:
def update_score_with_limit(self, article_id, delta, top_n=1000):
key = self.HOT_KEY
pipe = self.redis.pipeline()
# 用真实点赞数重设分数,而不是累加被裁掉后的残值
pipe.zadd(key, {str(article_id): self._real_count(article_id)})
pipe.zremrangebyrank(key, 0, -(top_n + 1))
pipe.execute()
优化 2:定期清理
限制大小解决的是”热榜”,但系统里通常还有一堆其他排行榜(24 小时榜、日榜、周榜、作者榜),它们各自需要独立的清理策略。
需要清理的 key:
- ranking:articles:hot 主榜,有裁剪
- ranking:hot:hour:* 小时桶,靠 TTL
- ranking:hot:day:* 日桶,靠 TTL
- ranking:authors:hot 作者榜,有裁剪
- ranking:articles:candidates 候选池
三类清理方式:
1. TTL 自动过期
小时桶:EXPIRE 48h
日桶: EXPIRE 30d
→ 最省心,但只能按时间维度清理
2. 定时任务主动裁剪
每天凌晨检查所有榜单,把低于阈值分数的成员删掉
→ 可以清理"很久没人看的榜单"
3. SCAN 找残留 key
某些 key 可能因为异常没设上 TTL,需要定期扫出来删掉
定时清理任务的实现:
def cleanup_rankings(redis_client, top_n=1000, min_score=0):
"""定期清理排行榜"""
keys = [
"ranking:articles:hot",
"ranking:authors:hot",
]
removed = 0
for key in keys:
# 裁剪到只保留前 top_n 名
removed += redis_client.zremrangebyrank(key, 0, -(top_n + 1))
# 删掉分数为 0 或负数的成员
removed += redis_client.zremrangebyscore(key, "-inf", min_score)
# 清理没有 TTL 的时间桶(用 SCAN,不要用 KEYS)
cursor = 0
while True:
cursor, batch = redis_client.scan(
cursor=cursor, match="ranking:hot:hour:*", count=200
)
for key in batch:
ttl = redis_client.ttl(key)
if ttl == -1: # -1 表示没有过期时间
redis_client.delete(key)
removed += 1
if cursor == 0:
break
return removed
SCAN 而不是 KEYS 是个硬性要求。
KEYS ranking:hot:hour:* → 阻塞 Redis 主线程,扫描期间所有请求排队
SCAN 0 MATCH ranking:hot:hour:* COUNT 200 → 分批返回,不阻塞
清理任务要放在低峰期跑,并且限速。
清理 100 万个 key:
每个 key 一次 DEL → 100 万次往返
→ 用 Pipeline 批量删,500 个一批
→ 或者用 UNLINK(异步删除,不阻塞)
UNLINK 比 DEL 更适合大批量删除。
DEL → 同步删除大对象时,主线程会卡住
UNLINK → 把对象放进"惰性删除"队列,由后台线程慢慢释放内存
清理的可观测性。
要记录:
- 每次清理删掉了多少个 key / 成员
- 清理耗时
- 清理前后的内存占用
如果某次清理删掉了异常多的东西,说明前期的写入逻辑有问题,要查。
优化 3:缓存排行榜结果
排行榜是典型的”读多写少”场景——1000 个用户刷排行榜,但每秒只有几十个赞。缓存排行榜结果收益很大。
class RankingCache:
"""排行榜结果缓存"""
def __init__(self, redis_client, ttl=30):
self.redis = redis_client
self.ttl = ttl
def get_top(self, limit=100):
key = f"cache:ranking:top:{limit}"
cached = self.redis.get(key)
if cached is not None:
return json.loads(cached)
# 未命中:查 ZSET 并回填
members = self.redis.zrevrange(
"ranking:articles:hot", 0, limit - 1, withscores=True
)
result = [
{"article_id": int(m), "rank": i + 1, "like_count": int(s)}
for i, (m, s) in enumerate(members)
]
self.redis.setex(key, self.ttl, json.dumps(result))
return result
def invalidate(self, limit=None):
"""榜单变化时让缓存失效"""
if limit is None:
# 清空所有榜单缓存(用 SCAN)
cursor = 0
while True:
cursor, keys = self.redis.scan(
cursor=cursor, match="cache:ranking:*", count=100
)
if keys:
self.redis.delete(*keys)
if cursor == 0:
break
else:
self.redis.delete(f"cache:ranking:top:{limit}")
缓存 TTL 与失效策略的取舍:
| 策略 | 说明 | 优点 | 缺点 |
|---|---|---|---|
| 纯 TTL | 到期自动失效 | 实现最简单 | 失效期内数据是旧的 |
| 纯失效 | 写入时删缓存 | 数据最新 | 每次写入都要删,且可能漏删 |
| TTL + 失效 | 两者结合 | 兼顾新鲜度和兜底 | 实现稍复杂 |
推荐 TTL + 失效:
写入时删缓存 → 保证大多数情况下数据是新的
TTL 兜底 → 万一漏删了,最多 TTL 秒后自动恢复
TTL 设多少合适?
排行榜缓存的 TTL = 用户能接受的数据陈旧时间
30 秒:几乎所有用户感知不到
60 秒:能明显降低缓存重建频率
热门榜单的缓存重建会有”击穿”问题。
缓存到期的那一刻,1000 个并发请求同时回源
→ 1000 次 ZREVRANGE + 1000 次 SETEX
解决办法是加一把互斥锁,只让第一个请求真正重建:
def get_top(self, limit=100):
key = f"cache:ranking:top:{limit}"
cached = self.redis.get(key)
if cached is not None:
return json.loads(cached)
# 尝试获取重建锁
lock_key = f"{key}:lock"
if self.redis.set(lock_key, 1, nx=True, ex=5):
try:
# 拿到锁:真正重建缓存
members = self.redis.zrevrange(...)
result = [...]
self.redis.setex(key, self.ttl, json.dumps(result))
return result
finally:
self.redis.delete(lock_key)
else:
# 没拿到锁:说明别人正在重建,等一下再读
time.sleep(0.05)
cached = self.redis.get(key)
return json.loads(cached) if cached else []
“不同页码分别缓存”能提高命中率。
cache:ranking:top:10 ← 移动端只展示 10 条
cache:ranking:top:100 ← PC 端展示 100 条
cache:ranking:top:20 ← 某些场景
分开缓存的好处是 10 条的缓存不会因为 100 条的失效而一起被清掉。
缓存的数据量要控制。
Top 100 的结果 JSON 大约 5~10 KB
1000 个不同的 limit 组合 → 10 MB
所以 limit 的取值要限定在一个白名单里,不要让前端传任意值。
练习 1
ZSET 的时间复杂度是多少?为什么?
解题思路:
这道题问的是 ZSET 各命令的复杂度及其来源,要逐条列出常用命令的复杂度,再解释底层数据结构(跳表 + 字典)为什么能把复杂度压到 O(log N)。
详细步骤:
ZSET 时间复杂度:
ZADD:O(log N)
- 插入/更新元素
- 需要调整排序树
ZINCRBY:O(log N)
- 原子性增加分数
- 需要调整排序树
ZRANGE/ZREVRANGE:O(log N + M)
- log N:找到起始位置
- M:返回 M 个元素
ZRANK/ZREVRANK:O(log N)
- 查找元素排名
- 需要遍历排序树
ZCOUNT:O(log N)
- 统计范围内的元素
- 需要查找范围边界
ZREMRANGEBYRANK:O(log N + M)
- log N:找到删除范围
- M:删除 M 个元素为什么是 O(log N):
ZSET 底层实现:
- 使用跳跃表(Skip List)
- 或使用字典树(Tree Map)
跳跃表结构:
- 多层索引
- 类似"快速通道"
- 查找时从高层开始
查找过程:
1. 从最高层开始
2. 快速跳过不相关的节点
3. 逐层下降
4. 找到目标元素
时间复杂度:O(log N)最终答案:
ZSET 的常用命令复杂度:ZADD / ZINCRBY / ZRANK / ZCOUNT 为 O(log N),ZRANGE / ZREVRANGE 为 O(log N + M)(M 是返回元素个数),ZREMRANGEBYRANK 为 O(log N + M)。之所以是 O(log N),是因为 ZSET 底层用跳表(Skip List)维护排序——查找从最高层开始逐层下降,每层跨过的节点数指数递减,总比较次数是 O(log N);分数到成员的映射再由字典负责 O(1) 定位。
练习 2
如何实现”分页查询”排行榜?
解题思路:
这道题问的是排行榜分页怎么实现,要先给出 ZREVRANGE 的基础做法,再指出深分页的性能问题并给出三种缓解办法。
详细步骤:
方案:使用 ZREVRANGE
性能问题:深分页
问题:
- 查询第 1000 页(start=19980, end=19999)
- Redis 需要遍历前 19999 个元素
- 性能差
解决方案:
1. 使用游标分页(基于分数)
2. 限制最大页数(只显示前 100 页)
3. 缓存热门页最终答案:
用 ZREVRANGE key start stop 实现分页,复杂度 O(log N + M)。但深分页(如第 1000 页)需要遍历前近 2 万个元素,性能差。缓解办法有三条:用基于分数的游标分页(推荐)、限制最大页数只开放前 100 页、缓存热门页。生产上优先做游标分页。
练习 3
如何实现”排名变化”功能?
解题思路:
这道题问的是怎么知道排名相较之前是升了还是降了,核心是要有排名历史。
详细步骤:
方案:记录排名历史
实现步骤:
- 定时快照:每 5~10 分钟把当前排名写入
rank:history:{yyyyMMddHHmm} - 保留策略:只保留最近 N 个时间片,过期的用定时任务删除
- 对比:当前名次 - 快照名次,得到升降
- 展示:结合分数变化给出『上升/下降 N 名』
注意:
- 快照频率是精度与成本的权衡
- 排名查询用 ZREVRANK,注意超大集合的定位成本
最终答案:
记录排名历史:定时任务把当前排名快照写入历史结构(Redis ZSET 快照 rank:history:{time},或时序库),用户查询时取当前名次与上一次快照的名次相减,得到升降名次;快照按时间分片存储、只保留最近若干个时间片(如 7 天),既控制存储也满足『最近变化』的查询需求。
练习 4
如何实现”段位排行榜”(青铜、白银、黄金)?
解题思路:
这道题问的是把一个排行榜拆成多个段位榜,核心是『分段维度的划分 + 归属判定』。
详细步骤:
方案:多个 ZSET
实现步骤:
- 定义段位与名次区间:如黄金 0
999、白银 10009999、青铜 10000+ - 定时任务:取用户全站排名,与区间比对决定归属段位
- 迁移动作:从旧段位 ZSET 中 ZREM,再 ZADD 到新段位 ZSET
- 展示:每个段位榜各自 ZREVRANGE 取 Top N
- 段位榜的分数可用段位内局部名次或统一用全站分数,但口径要统一
注意:
- 段位边界是按全站名次比例还是固定人数划分,要与产品确认
- 迁移动作要幂等,避免重复添加导致集合里出现幽灵成员
最终答案:
用多个 ZSET 实现段位榜:为每个段位建立一个独立的 ZSET(rank:bronze、rank:silver、rank:gold),写入时按用户当前名次落到对应段位集合,展示时各取自己的 Top N。段位归属由定时任务依据全站排名区间判定(如黄金前 10%、白银前 30%、青铜前 60%),并处理升降段时的迁移动作——从原段位集合移除、写入新段位集合。
练习 5
如何实现”排行榜实时推送”?
解题思路:
这道题问的是排行榜变化怎么实时推给用户,核心是『事件产生 → 订阅 → 推送』这条链路。
详细步骤:
方案:WebSocket + Pub/Sub
实现步骤:
- 事件产生:ZINCRBY 之后发布
rank:changed:{board_id}消息 - 消息通道:Redis Pub/Sub(简单)或 Redis Stream(可持久、可重放)
- 网关订阅:维护『谁在看哪个榜』的连接表
- 推送与节流:聚合 1 秒内的多次变化,一次推送 Top N
- 断线重连:客户端带最后版本号,增量补齐
注意:
- Pub/Sub 消息会丢,实时推送只能作为『锦上添花』,真实数据以拉取接口为准
- 高频榜单要限制订阅连接数,避免连接数成为瓶颈
最终答案:
用 WebSocket + Pub/Sub:点赞导致排名变化时发布消息到 Redis Pub/Sub 频道(或 Stream),网关服务订阅该频道,把变化推给正在看该榜单的在线连接;为了避免消息风暴,发布端要做节流与聚合(如 1 秒一次批量推送)。离线用户下次拉取时自然拿到最新数据——实时推送只作锦上添花,真实数据仍以拉取接口为准。
-
如何处理”分数相同”的情况?
-
如何实现”年度榜单”、“月度榜单”?
-
如何优化排行榜的”并发更新”性能?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
