去重展示
实现”点赞过这篇文章的用户”功能后,遇到了新问题。
场景:爆款文章
文章《创业者的一天》:
- 点赞数:10,000+
- 点赞用户:10,000 人
问题:
1. 一次性展示 10,000 个用户头像
- 页面加载慢
- 内存占用大
- 用户体验差
2. 重复的用户
- 用户可能多次点赞/取消点赞
- 需要去重
3. 如何展示?
- 展示所有 10,000 个用户?
- 只展示前 100 个?
- 分页展示?
需要设计合理的展示策略。
策略 1:限制数量
优点:
- 实现简单
- 性能好
- 用户体验可控
缺点:
- 看不到所有用户
- 可能不公平
策略 2:分页展示
优点:
- 可以查看所有用户
- 公平展示
- 页面加载快
缺点:
- 实现稍复杂
- 需要分页控件
策略 3:分层展示
优点:
- 优先展示重要用户
- 用户体验好
- 社交属性强
缺点:
- 实现复杂
- 需要社交关系数据
问题:重复点赞
场景:用户多次点赞/取消点赞
时间线:
T0: 用户点赞文章 A
T1: 用户取消点赞文章 A
T2: 用户再次点赞文章 A
问题:
- 点赞记录列表可能重复
- 需要去重
方案 1:使用 Sorted Set 自动去重
Sorted Set 同时提供了两个能力:元素唯一(自动去重)和按 score 排序(按点赞时间倒序)。用它存点赞用户,一份数据结构同时解决两个问题。
# 写入:score 是点赞时间戳,member 是用户 ID
ZADD article:123:liked_users 1710000000 1001
ZADD article:123:liked_users 1710000600 1002
# 同一个用户再次点赞 → member 相同,只更新 score,不会重复
ZADD article:123:liked_users 1710001200 1001
# 集合里始终只有 2 个成员,但 1001 的时间被更新了
ZCARD article:123:liked_users
"2"
“重复点赞”的两种业务语义:
语义 A:一个用户对同一篇文章只能有一条记录(点赞状态)
→ 用 Set,或者用 Sorted Set 但固定 score
语义 B:一个用户可以多次点赞,要保留"最近一次点赞时间"
→ 用 Sorted Set,score 存时间戳,重复点赞时更新 score
点赞计数通常要的是语义 B——用户取消后再点赞,列表里应该排到最前面。
Python 实现:
def like_with_time(article_id, user_id, timestamp=None):
"""点赞:Sorted Set 天然去重,同时记录最近点赞时间"""
ts = timestamp or int(time.time())
key = f"article:{article_id}:liked_users"
# ZADD 返回是否有新元素被添加
added = redis.zadd(key, {str(user_id): ts})
# 更新计数(用脚本保证原子,详见《Lua 脚本》)
count = redis.incr(f"article:{article_id}:like_count")
return {"added": bool(added), "like_count": count}
ZADD 的返回值说明了去重是否生效。
返回值 1 → 新增了一个成员(这次是真的首次点赞)
返回值 0 → 成员已存在,只更新了 score(重复点赞)
这个返回值可以直接用来决定”计数要不要加”——不过更稳妥的做法还是用 Lua 脚本把 ZADD 和 INCR 放在同一个脚本里。
读取点赞用户列表:
def get_liked_users(article_id, offset=0, limit=20):
"""按点赞时间倒序取点赞用户"""
key = f"article:{article_id}:liked_users"
# ZREVRANGE:按 score 倒序,WITHSCORES 一起返回分数
members = redis.zrevrange(key, offset, offset + limit - 1, withscores=True)
return [
{"user_id": int(uid), "liked_at": int(score)}
for uid, score in members
]
为什么用 ZREVRANGE 而不是 LRANGE?
| 命令 | 数据结构 | 排序 | 去重 |
|---|---|---|---|
| LRANGE | List | 按插入顺序 | 不会去重 |
| SMEMBERS | Set | 无序 | 自动去重 |
| ZREVRANGE | Sorted Set | 按 score 倒序 | 自动去重 |
我们要的是”按点赞时间倒序 + 去重”,只有 Sorted Set 同时满足。
Sorted Set 的代价:内存。
每个成员大约占用:
member 字符串 + score (8 字节 double) + 跳表索引 ≈ 60~80 字节
10000 个点赞用户:
10000 × 80 字节 ≈ 800 KB / 文章
对比 Set:
10000 × 约 50 字节 ≈ 500 KB / 文章
Sorted Set 比 Set 贵 50% 左右,换来的是排序能力。
方案 2:去重显示
Sorted Set 解决了存储层的去重,但还有一个问题:多个用户点赞了多篇文章时,文章列表里会重复出现同一个用户。
用户 A 点赞了文章 1、2、3
用户 B 点赞了文章 2
文章列表页要显示"最近点赞的人":
文章 1 → 用户 A
文章 2 → 用户 A, 用户 B ← 用户 A 出现了两次
文章 3 → 用户 A
去重显示的两种做法:
做法 A:存储层去重(推荐)
每篇文章各自一个 Sorted Set,文章内不重复。跨文章重复是展示时的问题,不是存储的问题。
存储:
article:1:liked_users = {1001}
article:2:liked_users = {1001, 1002}
article:3:liked_users = {1001}
展示:每篇文章独立取自己的点赞用户
→ 同一个用户在不同文章下出现,是正确的产品行为
做法 B:展示层去重(用于”我的关注流”)
如果产品要求”整个页面里同一个用户只出现一次”,就要在展示层做去重。
def get_dedup_liked_users(article_ids, limit=20):
"""跨文章去重:取最近的点赞用户,每人只出现一次"""
seen = set()
result = []
# 按时间倒序遍历文章,保证取到的是"最近"的
for article_id in article_ids:
key = f"article:{article_id}:liked_users"
members = redis.zrevrange(key, 0, limit - 1, withscores=True)
for uid, score in members:
uid = int(uid)
if uid in seen:
continue # 已经展示过,跳过
seen.add(uid)
result.append({"user_id": uid, "liked_at": int(score)})
if len(result) >= limit:
return result
return result
做法 B 的两个问题:
1. 复杂度随文章数线性增长。
20 篇文章 × 每篇取 20 个 = 400 次 ZREVRANGE 调用。这是典型的 N+1。
用 Pipeline 批量解决:
def get_dedup_liked_users_batch(article_ids, limit=20):
"""Pipeline 批量取回,再在应用层去重"""
pipe = redis.pipeline()
for article_id in article_ids:
pipe.zrevrange(f"article:{article_id}:liked_users", 0, limit - 1, withscores=True)
results = pipe.execute() # 1 次网络往返
seen = set()
result = []
for members in results:
for uid, score in members:
uid = int(uid)
if uid in seen:
continue
seen.add(uid)
result.append({"user_id": uid, "liked_at": int(score)})
if len(result) >= limit:
return result
return result
2. 跨文章去重会丢失”顺序正确性”。
按文章逐个遍历意味着文章 1 的用户一定排在文章 2 的用户前面,但”最近点赞”的语义应该是跨所有文章按时间排序。要真正按时间排序,得把所有成员汇总后统一排序,内存和计算成本都会上去。
实践中的取舍:
| 需求 | 方案 | 复杂度 |
|---|---|---|
| 每篇文章显示自己的点赞用户 | 存储层去重 + 独立读取 | O(1) |
| 页面内同一用户只出现一次 | 展示层去重 + Pipeline | O(N) |
| 跨文章严格按时间排序去重 | 汇总后统一排序 | O(N log N) |
绝大多数点赞场景只需要第一种。
去重后的展示还要注意”数量”和”列表”的区别。
点赞总数:10,000 ← 这是真实计数,不能因为只展示 20 个就说"20 个赞"
展示列表:20 个 ← 只展示一部分
UI 上要区分清楚:
"10,000 人赞过" ← 总数
[头像][头像][头像]... +9,980 ← 展示
方案 3:前端去重
前端去重是最后的兜底手段:在已渲染的用户头像里,按 user_id 再过滤一遍。
const uniqueUsers = [...new Map(users.map(u => [u.user_id, u])).values()]
它为什么排在最后?
优点:实现最简单,不改后端
缺点:
- 去重发生在"已经加载完"之后,省不下网络和内存
- 用户可能在第 3 页才看到重复被去掉,体验割裂
- 无法减少后端的存储压力
推荐:使用 Sorted Set 自动去重
优化 1:懒加载
一次性加载 10,000 个用户头像会让页面超过 5MB。懒加载的做法是:只加载首屏,滚动到底时再加载下一页。
def get_liked_users_page(article_id, cursor=None, limit=20):
"""游标分页:基于点赞时间戳,支持无限滚动"""
key = f"article:{article_id}:liked_users"
if cursor is None:
# 第一页:取最新的 limit 个
members = redis.zrevrange(key, 0, limit - 1, withscores=True)
else:
# 后续页:用 (score, member) 做游标,从上次的位置继续
last_score, last_uid = cursor
members = redis.zrevrangebyscore(
key,
max=f"({last_score}", # 严格小于上次的时间戳
min="-inf",
start=None,
num=limit,
withscores=True,
)
if not members:
return {"users": [], "next_cursor": None}
# 同一时间戳可能有多条记录,需要用 member 做二次定位
last = members[-1]
next_cursor = (int(last[1]), int(last[0]))
return {
"users": [{"user_id": int(uid), "liked_at": int(score)}
for uid, score in members],
"next_cursor": next_cursor,
}
游标分页比 OFFSET 分页好的地方:
OFFSET 分页:
第 100 页需要跳过前 1980 条 → 越翻越慢
而且翻页过程中数据变化会导致重复/遗漏
游标分页:
每次都从"上次停下的位置"继续 → 复杂度恒定
代价:不能跳到指定页
ZREVRANGEBYSCORE 的独占区间 (score 很关键。
max=f"({last_score}" → 严格小于上次的时间戳
如果用闭区间 max=last_score,而有多条记录的时间戳相同,就会重复返回它们。独占区间 + 用 member 二次定位才能保证不重不漏。
同一个时间戳有多条记录的处理:
用户 A 和 B 在同一秒点赞:
A → score=1710000000
B → score=1710000000
游标只带 score 的话,翻页时会漏掉其中一条
严格的做法是游标带 (score, member),用 ZRANGEBYSCORE 拿到 score 相同的一批后,在应用层按 member 再过滤一遍。
后端接口设计:
GET /api/articles/123/liked_users?cursor=1710000000:1001&limit=20
响应:
{
"users": [
{"user_id": 1001, "name": "张三", "avatar": "https://cdn.../1001.jpg", "liked_at": 1710000000}
],
"next_cursor": "1710000000:1001",
"has_more": true
}
前端配合(IntersectionObserver):
// 滚动到列表底部时加载下一页
const observer = new IntersectionObserver(async (entries) => {
if (entries[0].isIntersecting && hasMore && !loading) {
loading = true;
const next = await fetchLikedUsers(nextCursor);
appendUsers(next.users);
nextCursor = next.next_cursor;
hasMore = next.has_more;
loading = false;
}
});
observer.observe(loadMoreSentinel);
懒加载的代价:
- 首屏之后仍有加载延迟(用户可能感知到"卡一下")
- 需要前端配合做加载状态和错误重试
- 爬虫/SEO 抓取不到完整列表(对点赞列表不重要)
对点赞列表这个场景,懒加载是必需的:它同时解决了首屏速度、内存占用和”无限滚动”三个问题。
优化 2:虚拟滚动
懒加载解决了”一次不加载太多”,但已加载的部分仍然全部渲染在 DOM 里。用户滚到第 50 页时,DOM 里可能有 1000 个头像节点。
1000 个头像节点的 DOM:
- 内存占用:约 20~50 MB
- 布局计算:滚动时明显卡顿
- 首次渲染:即使只显示 20 个,也要先创建 1000 个节点
虚拟滚动的核心思想:只渲染”视口内 + 少量缓冲”的元素。
总列表:1000 条
视口高度:800px
每项高度:56px
可见项数:约 15 条
缓冲:上下各 10 条
→ 实际 DOM 节点:约 35 个,而不是 1000 个
实现要点:
1. 用一个占位容器撑起总高度
<div style="height: 1000 * 56px"> ← 滚动条长度正确
<div style="transform: translateY(offset)">
...只渲染可见的 35 个节点...
</div>
</div>
2. 监听 scroll,计算当前应该显示的起始索引
const startIndex = Math.floor(scrollTop / itemHeight) - buffer
const endIndex = startIndex + visibleCount + buffer * 2
3. 只渲染 [startIndex, endIndex) 区间
React 示例:
function VirtualList({ items, itemHeight, containerHeight }) {
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(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) => (
<UserRow key={item.user_id} user={item} height={itemHeight} />
))}
</div>
</div>
</div>
)
}
虚拟滚动的三个坑:
1. 动态高度。
上面的实现假设每行高度固定(56px)。如果头像有不同尺寸、行高不定,就要用”预估高度 + 实际测量回填”的方式,复杂度会高很多。点赞列表的头像通常是固定尺寸的,用固定高度就够。
2. 滚动抖动。
setStartIndex 触发的重渲染如果发生在滚动过程中,会有一帧的延迟。生产上通常用 requestAnimationFrame 节流。
3. 搜索/定位功能失效。
虚拟列表里没渲染的项在 DOM 中不存在,“Ctrl+F 搜索”找不到它们。对点赞列表不重要,但如果列表有筛选/搜索需求,要么把所有项都渲染,要么自己实现搜索跳转。
虚拟滚动 vs 懒加载的分工:
| 技术 | 解决什么 | 减少什么 |
|---|---|---|
| 懒加载 | 分批取数据 | 网络传输量、内存中的数据量 |
| 虚拟滚动 | 只渲染可见部分 | DOM 节点数、布局计算量 |
两者是互补的:懒加载负责”数据还没来”,虚拟滚动负责”数据来了但不该全画”。生产上通常两个一起用。
优化 3:头像 CDN 加速
前两个优化解决了”数据”和”DOM”,但头像图片本身也可能是瓶颈。
1000 个用户头像,每张 50KB:
页面大小:50 MB
加载时间:即使 CDN 也要十几秒
首次访问的用户几乎看不到内容
优化一:图片懒加载。
<img src="..." loading="lazy" />
浏览器原生支持,现代浏览器覆盖率很高。配合虚拟滚动,效果更好——只有真正进入视口的图片才会发起请求。
优化二:用 CDN 分发。
原始方案:
应用服务器 → 头像存储 → 返回图片
应用服务器的带宽成了瓶颈
CDN 方案:
应用服务器 → 返回 CDN URL
用户 → CDN 边缘节点 → 头像存储
def get_user_avatar(user_id):
"""返回 CDN 地址而不是存储地址"""
return f"https://cdn.example.com/avatar/{user_id}.jpg"
CDN URL 的设计要点:
1. 版本号在路径里,内容变了换路径(不用清缓存)
https://cdn.example.com/avatar/{user_id}/v{version}.jpg
2. 或者用内容哈希
https://cdn.example.com/avatar/{hash}.jpg
3. 用户 ID 变化时(换头像)递增版本号
优化三:缩略图。
列表页不需要 200×200 的原图:
列表用 48×48 或 64×64
个人主页用 200×200
同一份原图,按需生成多个尺寸
优化四:WebP / AVIF 格式。
JPEG 头像:50 KB
WebP 头像:25 KB (体积减半)
AVIF 头像:18 KB (体积再减 30%)
优化五:限制展示的头像数量。
这其实是本节最有效的一招——回到《去重展示》一节的策略 1:
只展示前 20~100 个头像 + "还有 9,980 人"
页面大小从 50MB 直接降到 50KB,比任何图片优化都有效。图片优化是在”必须展示很多”的前提下减少开销。
优化后的效果:
优化前:
1000 个头像,全部加载
页面大小:50 MB
首屏时间:12 秒
优化后(懒加载 + 虚拟滚动 + CDN + 缩略图 + 限流展示):
视口内 35 个头像,按需加载
页面大小:约 1.8 MB(其中 JS/CSS 占 400KB)
首屏时间:0.8 秒
优化手段的性价比排序:
| 手段 | 效果 | 成本 | 优先级 |
|---|---|---|---|
| 限制展示数量 | 极大 | 低 | 最高 |
| 懒加载 | 大 | 低 | 高 |
| 虚拟滚动 | 大 | 中 | 高 |
| CDN 加速 | 中 | 中 | 中 |
| 缩略图 + WebP | 中 | 低 | 中 |
先做”限制展示数量”,再考虑 CDN。 这是最容易被忽略、但收益最大的优化。
性能对比
场景:10,000 个点赞用户
方案 1:一次性加载
- 数据量:10,000 个用户
- 页面大小:约 5 MB
- 加载时间:约 3 秒
- 用户体验:差
方案 2:限制数量(100 个)
- 数据量:100 个用户
- 页面大小:约 50 KB
- 加载时间:约 0.2 秒
- 用户体验:好
方案 3:分页(每页 50 个)
- 数据量:50 个用户/页
- 页面大小:约 25 KB
- 加载时间:约 0.1 秒
- 用户体验:很好
存储优化
优化前:
- 每篇文章存储所有点赞用户
- 10,000 个用户 × 100 字节 = 1 MB/文章
- 10,000 篇热门文章 = 10 GB
优化后:
- 每篇文章只存储最近 100 个用户
- 100 个用户 × 100 字节 = 10 KB/文章
- 10,000 篇文章 = 100 MB
节省:99%
练习 1
如何实现”随机展示”点赞用户?
解题思路:
这道题问的是怎么在不遍历全量用户的前提下随机取几个人出来,答案取决于用哪种数据结构承载点赞用户。
详细步骤:
方案:使用 Sorted Set + 随机
实现步骤:
- 写入时
ZADD article:{id}:liked random_score user_id,分数用带时间戳的随机值,保证可重复计算 - 展示时
ZRANDMEMBER article:{id}:liked 5(Redis 6.2+)或从 Set 中SPOP - 需要权重时用 ZSET 的分数承载权重,
ZRANDMEMBER key count WITHSCORES
注意:
SRANDMEMBER对大集合是 O(N)(不重复取值时),数据量大时优先用ZRANDMEMBER- 随机展示会偏向后来点赞的用户,若要均匀可对分数做归一化处理
- 需要稳定顺序时改用按时间排序的 ZSET + 游标
最终答案:
用 Redis Sorted Set 承载点赞用户并按随机权重打分:点赞时以一个随机分数(如时间戳或随机值)写入 ZSET,展示时用 ZRANDMEMBER 随机取出 N 个用户,每次取样都是 O(log N) 级别、无需遍历全量。数据量小的时候也可以直接用 Set 的 SPOP / SRANDMEMBER。
练习 2
如何实现”按权重展示”点赞用户?
解题思路:
这道题问的是展示顺序由权重决定(而非时间或随机),权重通常来自用户活跃度、亲密度等信号。
详细步骤:
方案:综合评分排序
权重设计:
- 权重来源:用户活跃度、是否好友、内容偏好标签、最近互动次数
- 时间衰减:
score = base_score * exp(-λ * age),越新的点赞权重越高 - 写入时用 ZADD 直接带上分数;权重更新用 ZINCRBY 增量调整
- 展示用 ZREVRANGE 取前 N,重算任务定期批量刷新分数
注意:
- 权重刷新是批量操作,要限速避免阻塞 Redis
- 分数变化会影响历史展示顺序,需要产品侧确认是否接受
最终答案:
用 ZSET 的分数承载权重:维护 article:{id}:liked 这个有序集合,score = 综合权重(例如点赞时间衰减 × 用户活跃度 × 亲密度),写入与权重变化时用 ZADD / ZINCRBY 更新分数,展示时用 ZREVRANGE 取权重最高的 N 个,复杂度 O(log N + M)。权重需要重算时,配合定期重算任务批量刷新分数。
练习 3
如何实现”折叠”重复用户?
解题思路:
这道题问的是同一个人在一篇文章下只能出现一次,要区分『存储去重』和『展示折叠』两件事。
详细步骤:
方案:折叠相同用户的多次点赞
实现步骤:
- 存储层:ZSET 的 member 是 user_id,天然唯一,重复点赞只会更新分数
- 展示层:把取到的 N 条记录在应用层用 Map 按 user_id 聚合,保留分数最高(最新)的一条
- 折叠后数量不足时,继续从 ZSET 中多取一些补齐
注意:
- 折叠一定要在取够数量之后再做,否则会出现展示位不足
- 若需求是『同一用户的多条记录合并显示为一条(如显示点赞 3 次)』,则要保留计数信息而不是直接丢弃
最终答案:
折叠在展示层做:点赞用户用 ZSET/Set 存储时天然按 user_id 去重,同一用户多次点赞只保留一条记录(分数取最近一次);如果用户可能在多篇文章下重复出现,则在渲染时按 user_id 做一次分组聚合,用 Map 折叠后再取前 N,避免单个用户占满展示位。
练习 4
如何实现”搜索”点赞用户?
解题思路:
这道题问的是在点赞用户里按条件找人,核心是『过滤放在客户端还是服务端做』。
详细步骤:
方案:客户端过滤
优化:使用 Redis Search
两档方案:
- 客户端过滤:取回候选集合(限制在几百~几千条)后在应用层过滤
- 优点:实现简单,无需额外组件
- 缺点:候选集大时网络与内存开销高
- 服务端检索:Redis Search / RediSearch 或 ES 建立 user_id + 昵称的索引
- 优点:可支持任意条件、结果分页
- 缺点:引入额外组件与索引同步成本
注意:
- 昵称搜索要做前缀匹配与转义,避免注入与全表扫
- 搜索范围必须限定在当前文章的点赞用户集合内
最终答案:
小数据量时客户端过滤即可:把该文章的点赞用户列表一次性取回(用 SSCAN/ZRANGE 分批),在应用层按昵称前缀、活跃度等条件过滤,复杂度 O(N) 但实现最简单;用户量大时改用 Redis Search 或搜索引擎建立索引,把过滤下推到服务端,配合 ZSET 分数做排序取 Top N。无论哪种,搜索范围都必须限定在当前文章的点赞用户集合内。
练习 5
如何实现”关注”功能(一键关注所有点赞用户)?
解题思路:
这道题问的是批量把点赞的人变成关注对象,核心是『批量写 + 去重 + 幂等 + 限额』。
详细步骤:
方案:批量关注
实现步骤:
- 取目标用户列表:
ZRANGE article:{id}:liked 0 199或 SSCAN 分批拉取 - 去重与限额:过滤掉已关注的用户,限制单次最多 N 人
- 批量写入:用 Pipeline 一次性执行
SADD follower:{me}{uids}SADD following:{uid}{me}SADD following:{me}{uids}
- 幂等:集合语义天然去重,重复调用结果一致
注意:
- 要防止关注列表被撑爆:单次上限 + 每日上限
- 批量命令的参数个数有限,超大量时需要分片提交
最终答案:
用批量关注实现:先从点赞集合里取出目标用户列表(用 ZRANGE/SSCAN 分批),再用 Redis Pipeline 把 SADD follower:{my_id} 与 SADD following:{target_id} 批量写入,一次网络往返完成;集合语义天然去重,保证重复关注不会产生重复关系。同时要加数量上限(如单次最多关注 200 人)和频率限制,避免被刷。
-
如何实现”点赞用户的活跃度排序”(经常互动的用户优先展示)?
-
如何处理”僵尸用户”(长期不活跃的用户)?
-
如何实现”批量取消关注”功能?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
