点赞记录
实现 Feed 流后,数据量快速增长。
数据增长:
第 1 周:
- 用户数:1,000
- 点赞总数:10,000
- 平均每用户:10 条点赞记录
第 4 周:
- 用户数:10,000
- 点赞总数:500,000
- 平均每用户:50 条点赞记录
第 12 周:
- 用户数:50,000
- 点赞总数:5,000,000
- 平均每用户:100 条点赞记录
问题:
- 存储成本快速增长
- 查询性能下降
- Redis 内存压力大
需要优化存储方案。
方案 1:全量存储
优点:
- 实现简单
- 数据完整
缺点:
- 存储成本高
- 内存占用大
存储成本估算:
假设:
- 用户数:50,000
- 平均每用户:100 条点赞记录
- 每条记录:16 字节(article_id: 8 bytes + score: 8 bytes)
总存储:
50,000 × 100 × 16 = 80 MB
如果增长到:
- 用户数:500,000
- 平均每用户:200 条
总存储:
500,000 × 200 × 16 = 1.6 GB
方案 2:限制存储
优点:
- 存储成本可控
- 内存占用稳定
缺点:
- 旧数据会丢失
- 不支持查看历史记录
适用场景:
- 只需要最近的记录
- 不需要完整历史
方案 3:分层存储(推荐)
优点:
- 存储成本优化
- 查询性能好(热数据)
- 支持历史查询(数据库)
缺点:
- 实现复杂
- 需要多层存储
存储成本对比:
全量存储:
- Redis:1.6 GB
- 数据库:5 GB
限制存储:
- Redis:200 MB
- 数据库:5 GB
- 节省:87.5%
分层存储:
- Redis(热):50 MB
- Redis(温):100 MB
- 数据库:5 GB
- 节省:90.6%
从数据库迁移到 Redis
迁移分两步:先灌计数,再灌记录。顺序不能反——记录先到、计数后到,中间会出现”有记录但数字是 0”的窗口。
import time
def migrate_all(db, redis_client, batch_size=1000):
"""全量迁移:先迁计数,再迁点赞记录"""
migrated_articles = 0
migrated_records = 0
# ---------- 第一步:迁移计数 ----------
# 用主键游标分页,避免 OFFSET 深分页
last_id = 0
while True:
rows = db.query(
"SELECT id, like_count FROM articles "
"WHERE id > %s ORDER BY id LIMIT %s",
(last_id, batch_size),
)
if not rows:
break
pipe = redis_client.pipeline()
for row in rows:
pipe.set(f"article:{row['id']}:like_count", row["like_count"])
last_id = row["id"]
pipe.execute()
migrated_articles += len(rows)
# ---------- 第二步:迁移点赞记录 ----------
last_id = 0
while True:
rows = db.query(
"SELECT id, article_id, user_id, created_at FROM article_likes "
"WHERE id > %s ORDER BY id LIMIT %s",
(last_id, batch_size),
)
if not rows:
break
# 按 article_id 分组,一次 ZADD 一篇文章的全部点赞用户
grouped = defaultdict(dict)
for row in rows:
grouped[row["article_id"]][str(row["user_id"])] = row["created_at"]
pipe = redis_client.pipeline()
for article_id, members in grouped.items():
pipe.zadd(f"article:{article_id}:liked_users", members)
last_id = rows[-1]["id"]
pipe.execute()
migrated_records += len(rows)
return migrated_articles, migrated_records
迁移的三个关键点:
1. 用主键游标分页,不要用 OFFSET。
错误:
SELECT ... FROM article_likes ORDER BY id LIMIT 1000 OFFSET 500000
→ 每翻一页都要扫描前 500000 行,迁移 500 万条记录会慢到无法忍受
正确:
SELECT ... WHERE id > ? ORDER BY id LIMIT 1000
→ 每页都走主键索引,复杂度恒定
2. 用 Pipeline 批量写入。
每条记录一次 ZADD 就是一次往返,500 万条记录要走 500 万次往返。用 Pipeline 打包后降到 5000 次(每批 1000 条)。
3. 按 article_id 分组再 ZADD。
一条 ZADD 可以带多个 member:
ZADD article:123:liked_users 1710000000 1001 1710000600 1002 1710001200 1003
把同一篇文章的点赞用户攒在一起一次写入,比逐个 SADD 快得多。
迁移期间必须保证读路径不被打断。
方案 A:双写过渡
迁移开始 → 应用同时写 MySQL 和 Redis
老数据从 MySQL 读,新数据从 Redis 读
→ 需要一个"哪些文章已迁移"的标记
方案 B:停写迁移
暂停点赞写入 → 全量迁移 → 恢复写入
→ 数据一致,但有停机窗口
方案 C:灰度迁移
按 article_id 哈希取模,只迁移一部分
→ 每篇文章要么在 MySQL,要么在 Redis,路由由标记决定
大多数系统用方案 C,因为它可以分批推进、随时暂停、风险可控。
# 迁移标记放在 Redis,读路径先查标记
def get_like_count(article_id):
if redis.exists(f"migrated:article:{article_id}"):
return int(redis.get(f"article:{article_id}:like_count"))
return db.query("SELECT like_count FROM articles WHERE id = ?", (article_id,))[0]["like_count"]
迁移后的校验不能省。
# 抽样比对:Redis 和 MySQL 的计数必须一致
for article_id in random.sample(all_article_ids, 1000):
redis_count = int(redis.get(f"article:{article_id}:like_count") or 0)
db_count = db.query(
"SELECT COUNT(*) AS c FROM article_likes WHERE article_id = %s", (article_id,)
)[0]["c"]
if redis_count != db_count:
mismatches.append((article_id, redis_count, db_count))
不一致的文章要能重跑迁移。 迁移脚本必须设计成幂等的——重复执行不会产生错误数据。
增量同步
全量迁移只能覆盖”迁移时刻之前”的数据。迁移开始之后新产生的点赞记录,需要用增量同步补上。
方案一:基于时间戳的增量同步(简单)
def sync_incremental(db, redis_client, since, batch_size=1000):
"""按时间戳增量同步:拉取上次同步之后的新记录"""
last_time = since
synced = 0
while True:
rows = db.query(
"SELECT article_id, user_id, created_at FROM article_likes "
"WHERE created_at > %s ORDER BY created_at LIMIT %s",
(last_time, batch_size),
)
if not rows:
break
grouped = defaultdict(dict)
for row in rows:
grouped[row["article_id"]][str(row["user_id"])] = row["created_at"]
pipe = redis_client.pipeline()
for article_id, members in grouped.items():
pipe.zadd(f"article:{article_id}:liked_users", members)
last_time = rows[-1]["created_at"]
pipe.execute()
synced += len(rows)
return synced, last_time
这个方案有个致命的问题:时间戳会重复。
同一条记录的 created_at = 1710000000
本轮同步处理到了它,last_time = 1710000000
下一轮 WHERE created_at > 1710000000 → 这条记录被跳过了 ❌
解决办法:用 (created_at, id) 复合游标。
def sync_incremental_safe(db, redis_client, last_ts, last_id, batch_size=1000):
"""用 (created_at, id) 做复合游标,不会漏也不会重"""
rows = db.query(
"SELECT id, article_id, user_id, created_at FROM article_likes "
"WHERE (created_at, id) > (%s, %s) "
"ORDER BY created_at, id LIMIT %s",
(last_ts, last_id, batch_size),
)
if not rows:
return 0, last_ts, last_id
grouped = defaultdict(dict)
for row in rows:
grouped[row["article_id"]][str(row["user_id"])] = row["created_at"]
pipe = redis_client.pipeline()
for article_id, members in grouped.items():
pipe.zadd(f"article:{article_id}:liked_users", members)
pipe.execute()
last = rows[-1]
return len(rows), last["created_at"], last["id"]
这个游标必须和索引配套。
需要索引:(created_at, id)
否则每次扫描都要全表排序,500 万行会非常慢
方案二:binlog 订阅(更实时)
应用 → MySQL 写入 → binlog → Canal / Debezium → 消费端 → 写入 Redis
优点:
- 延迟低(通常 < 1 秒)
- 不需要轮询数据库
- 不受时间戳精度问题影响
缺点:
- 需要部署 binlog 采集和消费链路
- 要处理重复消费(消费端必须幂等)
- 要处理消费积压和乱序
因为 ZADD 天然幂等(member 相同就更新 score),重复消费不会产生脏数据,这让它比很多 CDC 场景轻松。
方案三:应用层双写(最直接)
点赞时同时写 MySQL 和 Redis
这就是《合并写入》一章讲的”异步同步”——写 Redis 立即返回,异步写 MySQL。数据库是最终真值,Redis 可以从数据库重建。
三种增量同步方案的对比:
| 方案 | 延迟 | 部署成本 | 可靠性 | 适用 |
|---|---|---|---|---|
| 时间戳轮询 | 分钟级 | 低 | 中(有漏数风险) | 低频、数据量小 |
| binlog 订阅 | 秒级 | 中 | 高 | 实时性要求高 |
| 应用层双写 | 立即 | 低 | 高(需处理写失败) | 已经在改代码 |
增量同步的一致性窗口是必须监控的指标。
监控项:
- 上次同步时间距今多久(同步延迟)
- 本次同步了多少条
- Redis 和 MySQL 的计数差异(对账)
优化 1:压缩存储
点赞记录里最占空间的是”用户 ID”。它是稀疏的整数序列,直接存文本浪费空间。
原始:ZADD article:123:liked_users 1001 1002 1003
每个 member 是一段字符串:"1001" ≈ 4 字节 + 字符串对象开销
改用整数编码:
ZADD article:123:liked_users 1001 1002 1003
→ Redis 内部对纯数字 member 会用整数编码,内存占用更低
Sorted Set 的 member 用整数编码是最直接的优化。
Redis 内部会判断 member 是否能表示为整数,能就用 intset/整数编码存储,省掉字符串对象和 SDS 头。
但真正的压缩要走”差值 + 位图”这条路。
点赞记录天然是有序的:用户 ID 递增,用户也倾向按顺序点赞。更进一步,如果按时间排序存储,那么”相邻两条记录的时间差”通常是很小的数。
差值编码(Delta Encoding):
原始时间戳:1710000000, 1710000005, 1710000003, 1710000010
差值: 1710000000, 5, -2, 7
→ 第一个存绝对值,后面只存差值
差值通常很小(< 100),可以用 1~2 字节表示
→ 时间戳从 4 字节降到 1~2 字节
def encode_delta_timestamps(timestamps):
"""把时间戳序列编码成差值数组"""
encoded = []
prev = 0
for ts in timestamps:
encoded.append(ts - prev)
prev = ts
return encoded
def decode_delta_timestamps(encoded):
"""解码回原始时间戳"""
result = []
current = 0
for delta in encoded:
current += delta
result.append(current)
return result
差值编码后,一个 Sorted Set 的成员只存”用户 ID + 差值”,score 都不需要了。
# 用 Hash 存差值,key 是用户 ID,value 是时间差
HSET article:123:liked_deltas 1001 0 1002 5 1003 -2
内存对比(10 万条点赞记录):
| 编码方式 | 每条字节 | 总内存 |
|---|---|---|
| ZSET(member 是字符串) | ~80 | 8 MB |
| ZSET(member 是整数) | ~56 | 5.6 MB |
| HASH + 差值 | ~24 | 2.4 MB |
| BITMAP(按位) | ~1 | 100 KB |
Bitmap 是压缩比最高的方案,但有前提。
BITMAP 方案:
每个用户占 1 bit,标记"是否点赞"
10000 篇文章 = 10000 bit = 1.25 KB
10 万用户 → 12.5 KB
限制:
- 需要文章 ID 连续(或者用哈希映射,但会有冲突)
- 不能按时间排序(丢失了时间信息)
- 只存"赞/没赞",不存"什么时候赞的"
所以 Bitmap 适合”用户点赞了哪些文章”的集合视图,不适合 Feed 流。
压缩的代价是查询会变复杂。
差值编码:
取第 100 条的时间戳 → 需要从头累加前 100 个差值 → O(N)
→ 需要配合 ZSET 的 score 排序,或者额外存一个索引
实际做法:
差值编码通常配合"分块":每 100 条存一个绝对值的检查点
查询第 N 条时,先二分找到最近的检查点,再累加不超过 100 个差值
→ 查询复杂度 O(log N + 100)
压缩的实际收益要和成本一起算。
10 万条记录:
ZSET(整数编码)5.6 MB vs HASH + 差值 2.4 MB
省下 3.2 MB
但代价是:
- 查询逻辑复杂,bug 风险上升
- 迁移和运维工具都要适配新格式
- 丢失了 ZSET 的天然排序能力
如果内存不是瓶颈,这笔账通常不划算。
更务实的优化顺序:
1. member 用整数(改动最小,收益立竿见影)
2. 限制每篇文章存储的记录数(ZREMRANGEBYRANK 裁剪)
3. 冷数据下沉到数据库(分层存储)
4. 只有在内存真的紧张时才考虑差值编码或 Bitmap
限制记录数是最划算的一招。
文章点赞 10 万人,但 Feed 只需要展示最近 100 条:
redis.zremrangebyrank(f"article:{article_id}:liked_users", 0, -(101))
内存从 8 MB 降到 8 KB
代价是”更早的点赞记录”查不到了——但那些数据本来就在数据库里,详见《去重展示》里的分层存储思路。
优化 2:Bitmap 存储
Bitmap 优缺点:
优点:
- 存储空间极小(每个用户只占 1 bit)
- 查询速度快
- 适合布尔值(点赞/未点赞)
缺点:
- 不支持时间排序
- 不适合稀疏数据
- 文章 ID 必须连续
练习 1
如何实现点赞记录的”软删除”?
解题思路:
这道题问的是『删除点赞但要保留痕迹』,核心是在表结构上加状态位而不是物理 DELETE。
详细步骤:
方案:添加删除标记
实现步骤:
- 加字段:
status TINYINT DEFAULT 1(或is_deleted) - 取消点赞改为:
UPDATE article_likes SET status = 0 WHERE article_id = ? AND user_id = ? - 查询只取有效记录:
WHERE article_id = ? AND status = 1 - 恢复能力:误删可以把 status 改回 1,且保留了操作痕迹
注意事项:
- 唯一索引要重新设计:唯一键应包含状态或改成普通索引,改为业务层保证不重复
- 软删除会让表不断膨胀,需要按时间把老数据归档或物理清理
最终答案:
在点赞记录表上增加状态字段(如 status:0 已删除 / 1 已点赞),删除时只做 UPDATE ... SET status = 0,不物理删除数据。这样保留了审计与恢复的可能,查询时用 WHERE status = 1 过滤。代价是表会持续变大,需要配合归档;唯一索引也要重新设计,避免唯一键与状态位冲突。
练习 2
如何实现点赞记录的”归档”?
解题思路:
这道题问的是历史点赞数据越积越多怎么处理,核心是『冷数据搬走、热数据留下』。
详细步骤:
方案:自动归档旧数据
归档步骤:
- 定义保留期与归档目标(归档表 / 对象存储 / 数仓)
- 定时任务按主键范围分批搬运:
WHERE created_at < ? LIMIT 5000 - 每批独立事务提交,避免大事务长时间锁表
- 搬运完成后校验行数,再从主表物理删除
- 归档前先固化聚合统计,供历史趋势查询
注意事项:
- 归档与在线查询会争抢 IO,要限速、安排在低峰期
- 必须先保证数据成功落到归档目标再删除源数据
最终答案:
用自动归档策略:按创建时间把超过保留期(如 6 个月)的点赞记录写入归档表或对象存储,并从主表物理删除;同时在归档前把统计结果(按天/文章汇总的点赞数)固化下来,保证历史趋势查询不依赖明细。归档任务用定时任务分批执行、限制每批行数,避免长事务锁表。
练习 3
如何实现点赞记录的”统计分析”?
解题思路:
这道题问的是怎么从明细记录里算出统计指标,核心是『不要在线扫明细』。
详细步骤:
方案:定期统计
实现步骤:
- 建统计表:
like_stat_daily(stat_date, article_id, like_count, unlike_count, ...),唯一键 (stat_date, article_id) - 定时任务扫描增量明细,按 (日期, 文章) 分组计数,用 upsert 累加写入
- 查询接口直接读统计表,走覆盖索引
- 实时性要求高的指标用 Redis INCR 维护,定期用统计任务校准
注意事项:
- 统计任务要幂等:重复执行不会重复累加
- 明细量太大时按时间范围分片扫描并限速
最终答案:
用定期统计(预聚合)而不是实时查询明细:定时任务按天/小时把点赞明细聚合成统计表(文章维度的点赞总量、用户维度的被赞数、时间维度的趋势),写入时用 INSERT ... ON DUPLICATE KEY UPDATE 做累加;查询时直接读统计表,O(1) 拿到结果。实时性要求高时,再叠加 Redis INCR 维护的实时计数,用明细统计定期校准。
练习 4
如何实现”批量导入”点赞记录?
解题思路:
这道题问的是一次性写入大量点赞记录怎么才快,核心是『减少网络往返和事务次数』。
详细步骤:
方案:使用 Pipeline 批量导入
实现步骤:
- 分批读入数据,每批 500~1000 条
- 用 Pipeline 批量提交,减少网络往返
- 用 Lua 脚本保证『判重 + 加成员 + 加计数』的原子性
- 大批量场景考虑直接生成 RDB/AOF 或用 redis-cli —pipe 离线导入
- 导入完成后核对明细数量与计数值是否一致
注意事项:
- 导入期间会占用 Redis CPU,建议低峰期执行并限速
- 需要幂等:重复导入同一条记录不应重复计数
最终答案:
用 Redis Pipeline 批量导入:把上千条 SADD article:{id}:liked 和 INCRBY article:{id}:like_count 打包成一次网络往返提交,管道大小控制在 1000 条以内;数据量大时再分批提交。同时用 Lua 脚本把『加计数 + 加成员 + 判重』合成一个原子操作,避免导入过程中出现计数与明细不一致。
练习 5
如何实现”跨天”的点赞记录查询?
解题思路:
这道题问的是查『某几天』范围内的点赞记录,核心是『用索引定位时间范围』而不是全表扫。
详细步骤:
方案:按日期分片存储
实现步骤:
- 存储侧按日期分片:
- MySQL 用 RANGE 分区(按 created_at)
- Redis 用
like:{article_id}:{yyyyMMdd}这样的日粒度 key
- 建复合索引
(user_id, created_at)或(article_id, created_at) - 查询时把日期条件写进 WHERE,由分区裁剪 + 索引扫描共同收敛范围
- 跨多天时按分区逐个查再归并,或用 UNION ALL
注意事项:
- 分片粒度要与查询维度对齐,避免『按天分片但按月查』的扫描放大
- 历史分片可以定期归档,缩短分区数量
最终答案:
按日期分片存储 + 合适的复合索引:点赞记录按 created_at 分区(MySQL 分区表,或按天拆成不同表/不同 key),并建 (user_id, created_at) 或 (article_id, created_at) 复合索引,查询跨天数据时先按日期范围裁剪分区,再在分区内走索引扫描,避免全表扫描。
-
如何设计一个支持”撤销”的点赞系统(可以撤销任意时间的点赞)?
-
如何实现”点赞提醒”(文章作者收到点赞通知)?
-
如何优化”超级用户”的 Feed 流存储(点赞数超过 10000)?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
