去重展示


展示问题

实现”点赞过这篇文章的用户”功能后,遇到了新问题。

场景:爆款文章

文章《创业者的一天》:
- 点赞数: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?

命令数据结构排序去重
LRANGEList按插入顺序不会去重
SMEMBERSSet无序自动去重
ZREVRANGESorted 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)
页面内同一用户只出现一次展示层去重 + PipelineO(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

如何实现”随机展示”点赞用户?

随机算法展示策略Redis

解题思路:

这道题问的是怎么在不遍历全量用户的前提下随机取几个人出来,答案取决于用哪种数据结构承载点赞用户。

详细步骤:

方案:使用 Sorted Set + 随机

实现步骤:

  1. 写入时 ZADD article:{id}:liked random_score user_id,分数用带时间戳的随机值,保证可重复计算
  2. 展示时 ZRANDMEMBER article:{id}:liked 5(Redis 6.2+)或从 Set 中 SPOP
  3. 需要权重时用 ZSET 的分数承载权重,ZRANDMEMBER key count WITHSCORES

注意:

  • SRANDMEMBER 对大集合是 O(N)(不重复取值时),数据量大时优先用 ZRANDMEMBER
  • 随机展示会偏向后来点赞的用户,若要均匀可对分数做归一化处理
  • 需要稳定顺序时改用按时间排序的 ZSET + 游标

最终答案:

用 Redis Sorted Set 承载点赞用户并按随机权重打分:点赞时以一个随机分数(如时间戳或随机值)写入 ZSET,展示时用 ZRANDMEMBER 随机取出 N 个用户,每次取样都是 O(log N) 级别、无需遍历全量。数据量小的时候也可以直接用 Set 的 SPOP / SRANDMEMBER。

练习 2

如何实现”按权重展示”点赞用户?

权重算法排序Redis

解题思路:

这道题问的是展示顺序由权重决定(而非时间或随机),权重通常来自用户活跃度、亲密度等信号。

详细步骤:

方案:综合评分排序

权重设计:

  1. 权重来源:用户活跃度、是否好友、内容偏好标签、最近互动次数
  2. 时间衰减:score = base_score * exp(-λ * age),越新的点赞权重越高
  3. 写入时用 ZADD 直接带上分数;权重更新用 ZINCRBY 增量调整
  4. 展示用 ZREVRANGE 取前 N,重算任务定期批量刷新分数

注意:

  • 权重刷新是批量操作,要限速避免阻塞 Redis
  • 分数变化会影响历史展示顺序,需要产品侧确认是否接受

最终答案:

用 ZSET 的分数承载权重:维护 article:{id}:liked 这个有序集合,score = 综合权重(例如点赞时间衰减 × 用户活跃度 × 亲密度),写入与权重变化时用 ZADD / ZINCRBY 更新分数,展示时用 ZREVRANGE 取权重最高的 N 个,复杂度 O(log N + M)。权重需要重算时,配合定期重算任务批量刷新分数。

练习 3

如何实现”折叠”重复用户?

UI设计折叠用户体验

解题思路:

这道题问的是同一个人在一篇文章下只能出现一次,要区分『存储去重』和『展示折叠』两件事。

详细步骤:

方案:折叠相同用户的多次点赞

实现步骤:

  1. 存储层:ZSET 的 member 是 user_id,天然唯一,重复点赞只会更新分数
  2. 展示层:把取到的 N 条记录在应用层用 Map 按 user_id 聚合,保留分数最高(最新)的一条
  3. 折叠后数量不足时,继续从 ZSET 中多取一些补齐

注意:

  • 折叠一定要在取够数量之后再做,否则会出现展示位不足
  • 若需求是『同一用户的多条记录合并显示为一条(如显示点赞 3 次)』,则要保留计数信息而不是直接丢弃

最终答案:

折叠在展示层做:点赞用户用 ZSET/Set 存储时天然按 user_id 去重,同一用户多次点赞只保留一条记录(分数取最近一次);如果用户可能在多篇文章下重复出现,则在渲染时按 user_id 做一次分组聚合,用 Map 折叠后再取前 N,避免单个用户占满展示位。

练习 4

如何实现”搜索”点赞用户?

搜索过滤Redis

解题思路:

这道题问的是在点赞用户里按条件找人,核心是『过滤放在客户端还是服务端做』。

详细步骤:

方案:客户端过滤

优化:使用 Redis Search

两档方案:

  1. 客户端过滤:取回候选集合(限制在几百~几千条)后在应用层过滤
    • 优点:实现简单,无需额外组件
    • 缺点:候选集大时网络与内存开销高
  2. 服务端检索:Redis Search / RediSearch 或 ES 建立 user_id + 昵称的索引
    • 优点:可支持任意条件、结果分页
    • 缺点:引入额外组件与索引同步成本

注意:

  • 昵称搜索要做前缀匹配与转义,避免注入与全表扫
  • 搜索范围必须限定在当前文章的点赞用户集合内

最终答案:

小数据量时客户端过滤即可:把该文章的点赞用户列表一次性取回(用 SSCAN/ZRANGE 分批),在应用层按昵称前缀、活跃度等条件过滤,复杂度 O(N) 但实现最简单;用户量大时改用 Redis Search 或搜索引擎建立索引,把过滤下推到服务端,配合 ZSET 分数做排序取 Top N。无论哪种,搜索范围都必须限定在当前文章的点赞用户集合内。

练习 5

如何实现”关注”功能(一键关注所有点赞用户)?

社交功能批量操作关注

解题思路:

这道题问的是批量把点赞的人变成关注对象,核心是『批量写 + 去重 + 幂等 + 限额』。

详细步骤:

方案:批量关注

实现步骤:

  1. 取目标用户列表:ZRANGE article:{id}:liked 0 199 或 SSCAN 分批拉取
  2. 去重与限额:过滤掉已关注的用户,限制单次最多 N 人
  3. 批量写入:用 Pipeline 一次性执行
    • SADD follower:{me} {uids}
    • SADD following:{uid} {me}
    • SADD following:{me} {uids}
  4. 幂等:集合语义天然去重,重复调用结果一致

注意:

  • 要防止关注列表被撑爆:单次上限 + 每日上限
  • 批量命令的参数个数有限,超大量时需要分片提交

最终答案:

用批量关注实现:先从点赞集合里取出目标用户列表(用 ZRANGE/SSCAN 分批),再用 Redis Pipeline 把 SADD follower:{my_id} 与 SADD following:{target_id} 批量写入,一次网络往返完成;集合语义天然去重,保证重复关注不会产生重复关系。同时要加数量上限(如单次最多关注 200 人)和频率限制,避免被刷。


思考题

  1. 如何实现”点赞用户的活跃度排序”(经常互动的用户优先展示)?

  2. 如何处理”僵尸用户”(长期不活跃的用户)?

  3. 如何实现”批量取消关注”功能?

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

发现内容有问题?

告诉我们哪里需要改进。