Feed 流模型


新的需求

系统运行稳定后,产品经理提出了新需求:

【需求文档】用户个人中心

功能 1:我点赞的文章
- 展示用户点赞过的所有文章
- 按点赞时间倒序排列
- 支持分页

功能 2:点赞过这篇文章的用户
- 展示点赞过某篇文章的所有用户
- 按点赞时间倒序排列
- 最多显示 100 个

功能 3:好友动态
- 展示好友最近的点赞动态
- 实时更新

这就是 Feed 流需求。


什么是 Feed 流?

Feed 流定义

Feed 流(信息流):
- 按时间顺序排列的内容流
- 持续更新的内容展示
- 用户可滚动浏览

常见场景:
- 微信朋友圈
- 微博首页
- 今日头条推荐
- Instagram

Feed 流类型

类型 1:Timeline 模型(时间线)

特点:
- 按内容发布时间排序
- 用户看到的是最新内容
- 算法简单,实现容易

示例:
- 微信朋友圈
- 微博关注页

类型 2:推荐模型

特点:
- 按算法推荐排序
- 个性化内容推荐
- 算法复杂,实现困难

示例:
- 今日头条
- 抖音推荐页
- Facebook Feed

点赞 Feed 流的特点

点赞 Feed 流:
- 属于 Timeline 模型
- 按点赞时间排序
- 用户主动操作产生
- 实时性要求高

与普通 Feed 流的区别:
1. 不是发布内容,而是互动行为
2. 需要双向关联(用户→文章,文章→用户)
3. 数据量可能更大(每个点赞都是一条记录)

数据模型设计

关系分析

用户点赞文章,产生两个关系:

关系 1:用户 → 文章
- 用户点赞了哪些文章?
- 用于"我点赞的文章"功能

关系 2:文章 → 用户
- 哪些用户点赞了这篇文章?
- 用于"点赞过这篇文章的用户"功能

数据结构设计

方案 1:关系表

数据设计要点

  • 核心是在 article_likes 里保存业务事实,而不是把规则散落在应用逻辑里。
  • 索引服务于高频查询,重点是缩小扫描范围,而不是堆更多字段。
  • 关键字段包括 id、article_id、user_id、created_at,它们决定后续查询和管理能力。

查询 SQL:

数据设计要点

  • 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。

优点:

  • 实现简单
  • 数据一致性好
  • 支持复杂查询

缺点:

  • 查询性能随数据量增长而下降
  • 分页查询慢(深分页)
  • 数据库压力大

方案 2:Redis List

优点:

  • 性能好
  • 实现简单
  • 支持分页

缺点:

  • 去重困难(List 不自动去重)
  • 内存占用大
  • 不支持复杂查询

方案 3:Redis Sorted Set(推荐)

优点:

  • 自动排序(按时间戳)
  • 自动去重
  • 支持范围查询
  • 性能好

缺点:

  • 内存占用相对大
  • 不支持复杂查询

推荐:使用 Sorted Set


完整方案

基础功能

Feed 流的三件事:写入(产生一条动态)、读取(按时间倒序拉取)、分页(游标翻页)。用 Sorted Set 可以一次搞定。

class FeedService:
    """基于 Sorted Set 的 Feed 流服务"""

    def __init__(self, redis_client, page_size=20):
        self.redis = redis_client
        self.page_size = page_size

    def _feed_key(self, user_id):
        return f"feed:user:{user_id}:likes"

    def publish(self, user_id, article_id, timestamp=None):
        """写入一条动态:点赞行为产生一条 Feed 记录"""
        ts = timestamp or int(time.time())
        # member 用 article_id,同一篇文章重复点赞只保留一条(最新时间)
        redis.zadd(self._feed_key(user_id), {str(article_id): ts})
        return ts

    def read(self, user_id, cursor=None, limit=None):
        """读取动态:按时间倒序 + 游标分页"""
        limit = limit or self.page_size
        key = self._feed_key(user_id)

        if cursor is None:
            members = redis.zrevrange(key, 0, limit - 1, withscores=True)
        else:
            last_score, last_member = cursor
            # 独占区间 + 同分记录的二次过滤
            members = redis.zrevrangebyscore(
                key, max=f"({last_score}", min="-inf",
                withscores=True,
            )
            # 过滤掉 score 相同且 member 不大于游标的那些
            members = [
                (m, s) for m, s in members
                if int(s) < last_score or (int(s) == last_score and m < last_member)
            ]
            members = members[:limit]

        if not members:
            return {"items": [], "next_cursor": None}

        last_member, last_score = members[-1]
        return {
            "items": [
                {"article_id": int(m), "liked_at": int(s)} for m, s in members
            ],
            "next_cursor": (int(last_score), last_member),
        }

    def remove(self, user_id, article_id):
        """删除一条动态(用户取消点赞)"""
        redis.zrem(self._feed_key(user_id), str(article_id))

为什么 Feed 流用 Sorted Set 而不是 List?

需求ListSorted Set
按时间倒序需要额外排序天然支持
去重不会去重member 唯一,自动去重
游标分页麻烦用 score 做游标很自然
删除某条O(N) 扫描O(log N)
内存占用更省略高

Sorted Set 用”member 唯一”换来了去重能力。

用户点赞文章 A,又取消,又点赞——Sorted Set 里始终只有一条 A 记录,时间戳被更新到最新。这正是”我的点赞列表”想要的效果。

但要注意:Sorted Set 的去重粒度是 member。

如果 Feed 需要”同一个人对同一篇文章的多次点赞都要保留”(比如带评论的点赞流),member 就不能只用 article_id,要拼上唯一 ID:

member = f"{article_id}:{like_record_id}"

游标分页里同分记录的处理是这个实现最微妙的地方。

时间戳精度是秒,同一秒内可能有多个动态:

    article:1 → score=1710000000
    article:2 → score=1710000000

如果游标只带 score,翻页时要么漏掉一条,要么重复一条

解决办法是游标带 (score, member),用 score 做粗筛(独占区间),再用 member 做精筛。

这个实现的代价是 ZREVRANGEBYSCORE 会返回区间内的全部成员。

如果某个 score 上挂了几千条成员,一次翻页会把它们全取回来。所以极端情况下要在 score 相同的成员上再限制数量。

集成到点赞功能

现在把 Feed 和点赞串起来:用户点赞 → 同时写入 Feed 记录。

class LikeServiceWithFeed:
    """点赞 + 维护个人 Feed 流"""

    def __init__(self, redis_client, feed_service):
        self.redis = redis_client
        self.feed = feed_service

    def like(self, article_id, user_id):
        """点赞:更新计数 + 写入 Feed"""
        count_key = f"article:{article_id}:like_count"
        liked_key = f"article:{article_id}:liked_users"

        # 用 Lua 保证"去重 + 计数 + Feed 写入"原子完成
        result = redis.eval(LIKE_WITH_FEED_SCRIPT, 3,
                            count_key, liked_key, self.feed._feed_key(user_id),
                            user_id, article_id)

        changed, count = result[0], result[1]
        return {"liked": True, "changed": bool(changed), "like_count": count}

    def unlike(self, article_id, user_id):
        """取消点赞:同时移除 Feed 记录"""
        count_key = f"article:{article_id}:like_count"
        liked_key = f"article:{article_id}:liked_users"

        result = redis.eval(UNLIKE_WITH_FEED_SCRIPT, 3,
                            count_key, liked_key, self.feed._feed_key(user_id),
                            user_id, article_id)

        changed, count = result[0], result[1]
        return {"liked": False, "changed": bool(changed), "like_count": count}
-- like_with_feed.lua
-- KEYS[1] = 计数器 article:{id}:like_count
-- KEYS[2] = 点赞集合 article:{id}:liked_users
-- KEYS[3] = 个人 Feed feed:user:{uid}:likes
-- ARGV[1] = user_id
-- ARGV[2] = article_id
-- ARGV[3] = 时间戳
if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 1 then
    return {0, tonumber(redis.call('GET', KEYS[1]) or '0')}
end

redis.call('SADD', KEYS[2], ARGV[1])
local count = redis.call('INCR', KEYS[1])
-- 同时写入个人 Feed 流
redis.call('ZADD', KEYS[3], ARGV[2], ARGV[3])

return {1, count}

为什么必须用 Lua 脚本把三件事绑在一起?

分开做:
    T1: SADD liked_users → 成功
    T2: INCR like_count → 失败(网络抖动)
    T3: ZADD feed → 没执行
    → 状态不一致:集合里有、计数没加、Feed 里没有

脚本里:
    三件事要么全做,要么全不做 ✅

还有一个”双写”问题:Feed 流是”谁点赞了什么”的反向索引。

数据关系:
    article:123:liked_users  →  {1001, 1002}     文章 → 用户
    feed:user:1001:likes     →  {123, 456}       用户 → 文章

这两份数据必须保持镜像关系。任何一处写了另一处没写,就会出现”我点赞了但我的列表里没有”或者”我的列表里有但显示未点赞”。

统一用同一个 Lua 脚本维护是唯一可靠的做法,靠应用层”记得两边都写”迟早会漏。

Feed 流的过期策略要单独考虑。

个人 Feed 流可能无限增长(用户点赞了 10 万篇文章)。必须限制:

1. 用 ZREMRANGEBYRANK 裁剪,只保留最近 N 条
   redis.zremrangebyrank(feed_key, 0, -(limit + 1))

2. 或者给 key 设置 TTL(但活跃用户的 key 不该过期)

“好友动态”是 Feed 流的另一面:聚合多个人的 Feed。

def get_friend_feed(self, user_ids, limit=20):
    """好友动态:把多个人的 Feed 合并后按时间排序"""
    pipe = self.redis.pipeline()
    for uid in user_ids:
        pipe.zrevrange(self.feed._feed_key(uid), 0, limit - 1, withscores=True)
    results = pipe.execute()

    # 合并所有用户的记录,按时间倒序
    merged = []
    for members in results:
        merged.extend(members)
    merged.sort(key=lambda x: x[1], reverse=True)

    return merged[:limit]

这个实现是”每人取 Top N 再合并”,不是真正的全局 Top N。

如果好友 A 有 100 条动态、好友 B 有 3 条,每人都取 20 条再合并,排序结果可能不是全局最靠前的 20 条。严格的做法是用 ZUNIONSTORE 在服务端做合并:

# Redis 6.2+ 支持 ZUNION,可以直接合并多个 ZSET
redis.zunionstore("feed:tmp", keys, aggregate="MAX")
result = redis.zrevrange("feed:tmp", 0, limit - 1, withscores=True)

性能优化

优化 1:Pipeline 批量查询

Feed 列表页要显示每条动态对应的文章标题、作者、点赞数。如果每条动态查一次,就是典型的 N+1。

错误:逐条查询
for item in feed_items:                      # 20 条
    article = db.query("SELECT ... WHERE id = ?", item["article_id"])   # 20 次
    likes = redis.get(f"article:{id}:like_count")                        # 20 次
# 合计 41 次往返

正确:Pipeline 一次取回所有计数。

def enrich_feed_items(self, feed_items):
    """用 Pipeline 批量补齐 Feed 条目的点赞数"""
    if not feed_items:
        return []

    pipe = self.redis.pipeline()
    for item in feed_items:
        pipe.get(f"article:{item['article_id']}:like_count")
    counts = pipe.execute()               # 1 次往返

    for item, raw in zip(feed_items, counts):
        item["like_count"] = int(raw) if raw is not None else 0
    return feed_items

Pipeline 把 20 次往返压缩成 1 次。

逐条查询:20 × 0.3ms = 6ms
Pipeline:  1 × 0.3ms + 20 × 0.02ms(服务端处理)≈ 0.7ms

文章详情(标题、作者)来自数据库,也要批量。

def enrich_articles_from_db(self, article_ids):
    """数据库侧用 IN 一次取回所有文章"""
    if not article_ids:
        return {}
    rows = self.db.query(
        f"SELECT id, title, author_id FROM articles "
        f"WHERE id IN ({','.join(str(int(i)) for i in article_ids)})"
    )
    return {row["id"]: row for row in rows}

数据库和 Redis 的查询要分开组织,不能交错。

错误:
    for item in feed_items:
        redis.get(...)        # 一次往返
        db.query(...)         # 又一次往返
    → 仍然是 2N 次

正确:
    1. 先把所有 Redis 查询攒进一个 Pipeline,一次执行
    2. 再把所有 DB 查询攒成一条 IN,一次执行
    → 2 次往返

Pipeline 的注意事项:

1. Pipeline 不是事务
   批量命令之间仍然可以被打断,只保证"打包发送",不保证"原子执行"

2. Pipeline 里不要放慢命令
   一条 BLOCK 命令会让后面的命令全部排队

3. 批量大小要控制
   一次 1000 条命令会让服务端内存和客户端缓冲都变大
   通常 100~500 条一批比较合适

Pipeline 和 Lua 脚本的分工:

需求方案
只要减少往返Pipeline
要求原子性Lua 脚本
既要原子又要批量Lua 脚本(循环处理多个 key)

Feed 列表页用 Pipeline 即可——列表数据允许有毫秒级的短暂不一致,不需要原子性。

优化 2:缓存热门数据

Feed 流里最热门的部分(好友动态的前几屏、热门文章的点赞用户)会被反复请求。缓存它们可以大幅降低 Redis 和数据库的压力。

class FeedCache:
    """Feed 热门数据缓存"""

    def __init__(self, redis_client, ttl=60):
        self.redis = redis_client
        self.ttl = ttl

    def _cache_key(self, user_id, page):
        return f"cache:feed:{user_id}:p{page}"

    def get_feed_page(self, user_id, page=0, feed_service=None):
        """读缓存,未命中回源并回填"""
        key = self._cache_key(user_id, page)

        cached = self.redis.get(key)
        if cached is not None:
            return json.loads(cached)

        # 未命中:回源
        items = feed_service.read(user_id, cursor=None)["items"]
        payload = json.dumps(items)
        self.redis.setex(key, self.ttl, payload)
        return items

    def invalidate(self, user_id):
        """用户点赞后,让他的 Feed 缓存失效"""
        # 用 SCAN 而不是 KEYS,避免阻塞 Redis
        cursor = 0
        while True:
            cursor, keys = self.redis.scan(
                cursor=cursor, match=f"cache:feed:{user_id}:p*", count=100
            )
            if keys:
                self.redis.delete(*keys)
            if cursor == 0:
                break

为什么要”按用户 + 页码”分键?

一个用户一个缓存 key:
    失效简单(直接 DEL)
    但翻到第 2 页时,缓存的是第 1 页的内容 ❌

按页分键:
    cache:feed:{uid}:p0, cache:feed:{uid}:p1, ...
    每页独立缓存,命中率高
    失效时删掉这个用户的所有页

SCAN 而不是 KEYS。

KEYS pattern   → 阻塞 Redis 主线程,扫描期间所有请求排队
SCAN cursor    → 每次只返回少量 key,多次调用完成扫描,不阻塞

KEYS 在生产环境是禁用的,这是 Redis 官方明确说明的命令。

缓存 TTL 怎么定?

TTL效果风险
10s新鲜度好缓存命中率低,Redis 压力大
60s平衡用户可能看到 1 分钟内的旧动态
300s命中率高新动态延迟可见

Feed 流的缓存有个特殊之处:它的”新”数据在第一页。

用户点赞了一篇文章 → 这条动态出现在第 0 页
→ 第 0 页的缓存必须失效,否则用户看不到自己刚赞的
→ 但后面几页的缓存不用失效

更精细的策略:只失效第一页。

def on_user_like(self, user_id):
    """点赞后只失效第一页缓存"""
    self.redis.delete(self._cache_key(user_id, 0))

但如果 Feed 有分页且用游标,第一页失效后游标也要重置——这会让正在翻页的用户体验断裂。实践中常见做法是:Feed 流不做写后失效,而是用短 TTL + 客户端合并。

用户点赞 → 前端本地插入一条 → 不用等服务端返回
→ 缓存里的旧数据最多 60 秒后才被看到

优化 3:懒加载

Feed 流的懒加载和普通列表一样:首屏只加载一屏,滚动到底再加载下一页。

def get_feed_page(self, user_id, cursor=None, limit=20):
    """Feed 流的懒加载接口"""
    result = self.feed.read(user_id, cursor=cursor, limit=limit)
    items = result["items"]

    # 批量补齐文章信息(Pipeline + 批量 SQL)
    article_ids = [item["article_id"] for item in items]
    articles = self.enrich_articles_from_db(article_ids)
    self.enrich_feed_items(items)

    # 合并
    for item in items:
        article = articles.get(item["article_id"])
        item["title"] = article["title"] if article else "文章已删除"
        item["author_id"] = article["author_id"] if article else None

    return {
        "items": items,
        "next_cursor": (
            f"{result['next_cursor'][0]}:{result['next_cursor'][1]}"
            if result["next_cursor"] else None
        ),
        "has_more": bool(result["next_cursor"]),
    }

游标要做成字符串传给前端。

游标是 (score, member) 元组,JSON 序列化后是数组:
    [1710000000, "123"]

前端应该把它当不透明字符串处理,只负责原样回传:
    "1710000000:123"

这样做的好处是后端可以随时改变游标的内部格式,前端不需要跟着改。

前端:

// 首屏
const firstPage = await fetchFeed(null)
// 滚动到底
const nextPage = await fetchFeed(nextCursor)

懒加载的三个常见问题:

1. 翻页时数据变了,导致重复或遗漏。

T0: 用户 A 拉第 1 页,看到 item1, item2
T1: 用户 B 点赞了 item3 → item3 排到了最前面
T2: 用户 A 拉第 2 页(游标指向 item2 之后)
    → item3 已经在第 1 页的位置,不会重复 ✅
    → 但如果 B 点赞的是 item0(比 A 的第一页更早),A 就永远看不到它了

这是 Feed 流固有的问题。业界的常见做法是接受它——用户刚点赞的内容,通常也会出现在”我的点赞”列表里,不会真正丢失。

2. 快速滚动会触发重复请求。

前端要用”加载中”标志位防止并发请求同一页。

3. 需要给”下拉刷新”设计好交互。

下拉刷新时游标要重置为 null,从头开始;同时要把已经加载的所有数据替换掉。

服务端也可以做”预取”优化。

每次返回一页时,顺带把下一页的数据取出来缓存起来
用户滚到底时直接命中缓存,零延迟

这相当于把懒加载的延迟藏在了上一次请求里。


课后练习

练习 1

如何实现”好友的点赞动态”功能?

Feed流社交功能Redis

解题思路:

这道题问的是把『我关注的人点赞了什么』聚合成一个 Feed 流,核心是写扩散与读扩散的选择。

详细步骤:

方案设计:

两种模式对比:

  • 写扩散(推):点赞时写入所有粉丝的队列
    • 优点:读取极快,一次请求拿到全部内容
    • 缺点:写放大严重,关注 10 万人就是 10 万次写
  • 读扩散(拉):读取时按关注列表拉取各来源的动态再归并
    • 优点:写开销小,适合大 V
    • 缺点:读取需要多次请求,延迟高

混合方案:

  • 普通用户(粉丝数 < 阈值)→ 写扩散
  • 大 V(粉丝数 ≥ 阈值)→ 读扩散,读取时单独拉取
  • 归并时按时间排序去重,Feed 长度保留最近 N 条

最终答案:

用写扩散(Fan-out on Write)实现:用户点赞时,把这条动态推入所有关注者的 Feed 队列(Redis List/ZSet feed:{user_id});读取时直接读自己的队列。为了控制写放大,当关注数超过阈值时改为读扩散(拉模式)——读取时从关注对象的动态列表里拉取并归并。实践上常用『大 V 走读扩散、普通用户走写扩散』的混合方案。

练习 2

如何处理 Feed 流的”分页空洞”问题?

Feed流分页数据处理

解题思路:

这道题问的是 offset 分页在有删除/插入时为什么会漏或重,要从『上一页的边界是什么』入手。

详细步骤:

问题分析:

分页空洞:
- 用户浏览第 1 页(20 条)
- 其他用户删除了 5 条内容
- 用户浏览第 2 页
- 可能出现重复或遗漏内容

解决方案:

成因与解法:

问题的根源是 offset 分页锚定的是「第几条」而不是「哪一条」:用户看第 1 页(20 条)后,其他用户删除了 5 条内容,第 2 页仍用 LIMIT 20, 20 定位,实际跳过的是删除后的第 20 条,于是 5 条内容被漏掉;新增内容同理会造成重复。

解决方案:

  1. 游标分页:记录上一页最后一条的 score + id 作为游标,下一页用严格小于继续
  2. 快照式分页:读取时先固定一个时间点,只返回该时间点之前的内容
  3. 数据分区:按天/周分区,避免扫描范围随数据量无限增长

最终答案:

用游标分页替代 offset 分页:不用 LIMIT offset, size,而是记住上一页最后一条的 (score, id) 作为游标,下一页用 WHERE score < last_score 继续取。因为游标锚定的是一个确定的排序位置,中间数据的增删不会让它漂移,从而消除空洞和重复。数据量极大时再配合按时间分区与归档控制扫描范围。

练习 3

如何实现 Feed 流的”实时更新”?

Feed流实时更新WebSocket

解题思路:

这道题问的是『新动态什么时候出现在用户面前』,要在轮询和推送之间选,并考虑推送的可靠性。

详细步骤:

方案:WebSocket 推送

实现步骤:

  1. 点赞事件写入 Redis Stream / Kafka,事件体含 article_id、user_id、ts
  2. 网关服务消费事件,按目标用户查找其在线连接
  3. 通过 WebSocket 推送,前端收到后插入 Feed 顶部
  4. 离线用户:事件写入其离线队列,上线时批量补推
  5. 断线重连:客户端携带最后一条 feed_id,服务端增量补齐

注意:

  • 推送是『尽力而为』,一致性仍以拉取接口为准
  • 要做前端去重与条数上限,防止刷屏

最终答案:

用 WebSocket 长连接推送:服务端的写事件先落到 Redis Stream 或消息队列,由连接网关消费后推给对应用户的在线连接;离线用户则把事件写进其离线队列,下次上线时补推。配合前端按 feed_id 去重、断线重连后的增量拉取,保证既实时又不重不漏。

练习 4

如何优化 Feed 流的存储空间?

Feed流存储优化Redis

解题思路:

这道题问的是 Feed 数据在 Redis 里越积越大的问题,要从『减少条目数』和『减少每条大小』两个方向考虑。

详细步骤:

优化方案:

具体做法:

  1. 条数上限:每个用户 Feed 保留最近 N 条,ZREMRANGEBYRANK 裁掉最旧的
  2. 字段精简:ZSET 只存 feed_id + score(时间戳),详情回源查 DB
  3. 冷热分离:超过活跃窗口的 Feed 转存到持久化存储
  4. 内存估算:元素较大时 ZSET 会从 listpack 转成 skiplist,注意单条大小

注意:

  • 裁剪要有节奏,避免在高峰期集中裁剪造成 Redis 卡顿
  • 裁剪前确认这些数据可以从源库重建

最终答案:

从三处省空间:一是限制每个用户 Feed 只保留最近 N 条(如 1000 条),用 ZREMRANGEBYRANK 定期裁剪;二是精简存储结构,只存 feed_id 和必要的摘要字段,详情用 id 回源查询;三是冷热分离,历史数据下沉到对象存储或数仓,只在 Redis 保留最近活跃窗口。

练习 5

如何实现 Feed 流的”去重”?

Feed流去重Redis

解题思路:

这道题问的是同一条动态在 Feed 里出现多次的问题,要区分『写入时去重』和『读取时去重』。

详细步骤:

方案:使用 Set 去重

去重层次:

  1. 存储层:ZSET 的 member 用唯一 feed_id,天然去重
    • ZADD feed:{uid} {ts} {feed_id} 重复调用只更新分数
  2. 读取层:读扩散归并多个来源时,用 Map 按 feed_id 去重
  3. 前端层:推送与拉取可能同时到达,前端按 feed_id 丢弃重复项

注意:

  • 读取层的去重 Map 要限制大小,避免一次性归并过大的列表
  • 去重键的选择要能唯一标识一条动态(feed_id 优先,不要用时间戳)

最终答案:

写入时用 ZSET 的 member 唯一性做去重——member 用 feed_id(或 user_id + article_id 的组合),重复推送只更新 score 而不新增条目;读取时再在应用层用一个定长 Map 做一次兜底去重,键为 feed_id。这样既保证了存储层不重复,也避免了合并多个来源时的重复展示。


思考题

  1. 如何实现”双向关注”的 Feed 流(只看互关好友的动态)?

  2. 如何处理 Feed 流的”已读/未读”状态?

  3. 如何实现 Feed 流的”置顶”功能?

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

发现内容有问题?

告诉我们哪里需要改进。