Feed 流模型
系统运行稳定后,产品经理提出了新需求:
【需求文档】用户个人中心
功能 1:我点赞的文章
- 展示用户点赞过的所有文章
- 按点赞时间倒序排列
- 支持分页
功能 2:点赞过这篇文章的用户
- 展示点赞过某篇文章的所有用户
- 按点赞时间倒序排列
- 最多显示 100 个
功能 3:好友动态
- 展示好友最近的点赞动态
- 实时更新
这就是 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?
| 需求 | List | Sorted 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 流,核心是写扩散与读扩散的选择。
详细步骤:
方案设计:
两种模式对比:
- 写扩散(推):点赞时写入所有粉丝的队列
- 优点:读取极快,一次请求拿到全部内容
- 缺点:写放大严重,关注 10 万人就是 10 万次写
- 读扩散(拉):读取时按关注列表拉取各来源的动态再归并
- 优点:写开销小,适合大 V
- 缺点:读取需要多次请求,延迟高
混合方案:
- 普通用户(粉丝数 < 阈值)→ 写扩散
- 大 V(粉丝数 ≥ 阈值)→ 读扩散,读取时单独拉取
- 归并时按时间排序去重,Feed 长度保留最近 N 条
最终答案:
用写扩散(Fan-out on Write)实现:用户点赞时,把这条动态推入所有关注者的 Feed 队列(Redis List/ZSet feed:{user_id});读取时直接读自己的队列。为了控制写放大,当关注数超过阈值时改为读扩散(拉模式)——读取时从关注对象的动态列表里拉取并归并。实践上常用『大 V 走读扩散、普通用户走写扩散』的混合方案。
练习 2
如何处理 Feed 流的”分页空洞”问题?
解题思路:
这道题问的是 offset 分页在有删除/插入时为什么会漏或重,要从『上一页的边界是什么』入手。
详细步骤:
问题分析:
分页空洞:
- 用户浏览第 1 页(20 条)
- 其他用户删除了 5 条内容
- 用户浏览第 2 页
- 可能出现重复或遗漏内容解决方案:
成因与解法:
问题的根源是 offset 分页锚定的是「第几条」而不是「哪一条」:用户看第 1 页(20 条)后,其他用户删除了 5 条内容,第 2 页仍用 LIMIT 20, 20 定位,实际跳过的是删除后的第 20 条,于是 5 条内容被漏掉;新增内容同理会造成重复。
解决方案:
- 游标分页:记录上一页最后一条的 score + id 作为游标,下一页用严格小于继续
- 快照式分页:读取时先固定一个时间点,只返回该时间点之前的内容
- 数据分区:按天/周分区,避免扫描范围随数据量无限增长
最终答案:
用游标分页替代 offset 分页:不用 LIMIT offset, size,而是记住上一页最后一条的 (score, id) 作为游标,下一页用 WHERE score < last_score 继续取。因为游标锚定的是一个确定的排序位置,中间数据的增删不会让它漂移,从而消除空洞和重复。数据量极大时再配合按时间分区与归档控制扫描范围。
练习 3
如何实现 Feed 流的”实时更新”?
解题思路:
这道题问的是『新动态什么时候出现在用户面前』,要在轮询和推送之间选,并考虑推送的可靠性。
详细步骤:
方案:WebSocket 推送
实现步骤:
- 点赞事件写入 Redis Stream / Kafka,事件体含 article_id、user_id、ts
- 网关服务消费事件,按目标用户查找其在线连接
- 通过 WebSocket 推送,前端收到后插入 Feed 顶部
- 离线用户:事件写入其离线队列,上线时批量补推
- 断线重连:客户端携带最后一条 feed_id,服务端增量补齐
注意:
- 推送是『尽力而为』,一致性仍以拉取接口为准
- 要做前端去重与条数上限,防止刷屏
最终答案:
用 WebSocket 长连接推送:服务端的写事件先落到 Redis Stream 或消息队列,由连接网关消费后推给对应用户的在线连接;离线用户则把事件写进其离线队列,下次上线时补推。配合前端按 feed_id 去重、断线重连后的增量拉取,保证既实时又不重不漏。
练习 4
如何优化 Feed 流的存储空间?
解题思路:
这道题问的是 Feed 数据在 Redis 里越积越大的问题,要从『减少条目数』和『减少每条大小』两个方向考虑。
详细步骤:
优化方案:
具体做法:
- 条数上限:每个用户 Feed 保留最近 N 条,ZREMRANGEBYRANK 裁掉最旧的
- 字段精简:ZSET 只存 feed_id + score(时间戳),详情回源查 DB
- 冷热分离:超过活跃窗口的 Feed 转存到持久化存储
- 内存估算:元素较大时 ZSET 会从 listpack 转成 skiplist,注意单条大小
注意:
- 裁剪要有节奏,避免在高峰期集中裁剪造成 Redis 卡顿
- 裁剪前确认这些数据可以从源库重建
最终答案:
从三处省空间:一是限制每个用户 Feed 只保留最近 N 条(如 1000 条),用 ZREMRANGEBYRANK 定期裁剪;二是精简存储结构,只存 feed_id 和必要的摘要字段,详情用 id 回源查询;三是冷热分离,历史数据下沉到对象存储或数仓,只在 Redis 保留最近活跃窗口。
练习 5
如何实现 Feed 流的”去重”?
解题思路:
这道题问的是同一条动态在 Feed 里出现多次的问题,要区分『写入时去重』和『读取时去重』。
详细步骤:
方案:使用 Set 去重
去重层次:
- 存储层:ZSET 的 member 用唯一 feed_id,天然去重
ZADD feed:{uid} {ts} {feed_id}重复调用只更新分数
- 读取层:读扩散归并多个来源时,用 Map 按 feed_id 去重
- 前端层:推送与拉取可能同时到达,前端按 feed_id 丢弃重复项
注意:
- 读取层的去重 Map 要限制大小,避免一次性归并过大的列表
- 去重键的选择要能唯一标识一条动态(feed_id 优先,不要用时间戳)
最终答案:
写入时用 ZSET 的 member 唯一性做去重——member 用 feed_id(或 user_id + article_id 的组合),重复推送只更新 score 而不新增条目;读取时再在应用层用一个定长 Map 做一次兜底去重,键为 feed_id。这样既保证了存储层不重复,也避免了合并多个来源时的重复展示。
-
如何实现”双向关注”的 Feed 流(只看互关好友的动态)?
-
如何处理 Feed 流的”已读/未读”状态?
-
如何实现 Feed 流的”置顶”功能?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
