点赞记录


存储挑战

实现 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 是字符串)~808 MB
ZSET(member 是整数)~565.6 MB
HASH + 差值~242.4 MB
BITMAP(按位)~1100 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。

详细步骤:

方案:添加删除标记

实现步骤:

  1. 加字段:status TINYINT DEFAULT 1(或 is_deleted)
  2. 取消点赞改为:UPDATE article_likes SET status = 0 WHERE article_id = ? AND user_id = ?
  3. 查询只取有效记录:WHERE article_id = ? AND status = 1
  4. 恢复能力:误删可以把 status 改回 1,且保留了操作痕迹

注意事项:

  • 唯一索引要重新设计:唯一键应包含状态或改成普通索引,改为业务层保证不重复
  • 软删除会让表不断膨胀,需要按时间把老数据归档或物理清理

最终答案:

在点赞记录表上增加状态字段(如 status:0 已删除 / 1 已点赞),删除时只做 UPDATE ... SET status = 0,不物理删除数据。这样保留了审计与恢复的可能,查询时用 WHERE status = 1 过滤。代价是表会持续变大,需要配合归档;唯一索引也要重新设计,避免唯一键与状态位冲突。

练习 2

如何实现点赞记录的”归档”?

数据归档存储优化生命周期

解题思路:

这道题问的是历史点赞数据越积越多怎么处理,核心是『冷数据搬走、热数据留下』。

详细步骤:

方案:自动归档旧数据

归档步骤:

  1. 定义保留期与归档目标(归档表 / 对象存储 / 数仓)
  2. 定时任务按主键范围分批搬运:WHERE created_at < ? LIMIT 5000
  3. 每批独立事务提交,避免大事务长时间锁表
  4. 搬运完成后校验行数,再从主表物理删除
  5. 归档前先固化聚合统计,供历史趋势查询

注意事项:

  • 归档与在线查询会争抢 IO,要限速、安排在低峰期
  • 必须先保证数据成功落到归档目标再删除源数据

最终答案:

用自动归档策略:按创建时间把超过保留期(如 6 个月)的点赞记录写入归档表或对象存储,并从主表物理删除;同时在归档前把统计结果(按天/文章汇总的点赞数)固化下来,保证历史趋势查询不依赖明细。归档任务用定时任务分批执行、限制每批行数,避免长事务锁表。

练习 3

如何实现点赞记录的”统计分析”?

数据分析统计聚合

解题思路:

这道题问的是怎么从明细记录里算出统计指标,核心是『不要在线扫明细』。

详细步骤:

方案:定期统计

实现步骤:

  1. 建统计表:like_stat_daily(stat_date, article_id, like_count, unlike_count, ...),唯一键 (stat_date, article_id)
  2. 定时任务扫描增量明细,按 (日期, 文章) 分组计数,用 upsert 累加写入
  3. 查询接口直接读统计表,走覆盖索引
  4. 实时性要求高的指标用 Redis INCR 维护,定期用统计任务校准

注意事项:

  • 统计任务要幂等:重复执行不会重复累加
  • 明细量太大时按时间范围分片扫描并限速

最终答案:

用定期统计(预聚合)而不是实时查询明细:定时任务按天/小时把点赞明细聚合成统计表(文章维度的点赞总量、用户维度的被赞数、时间维度的趋势),写入时用 INSERT ... ON DUPLICATE KEY UPDATE 做累加;查询时直接读统计表,O(1) 拿到结果。实时性要求高时,再叠加 Redis INCR 维护的实时计数,用明细统计定期校准。

练习 4

如何实现”批量导入”点赞记录?

数据导入批量操作性能

解题思路:

这道题问的是一次性写入大量点赞记录怎么才快,核心是『减少网络往返和事务次数』。

详细步骤:

方案:使用 Pipeline 批量导入

实现步骤:

  1. 分批读入数据,每批 500~1000 条
  2. 用 Pipeline 批量提交,减少网络往返
  3. 用 Lua 脚本保证『判重 + 加成员 + 加计数』的原子性
  4. 大批量场景考虑直接生成 RDB/AOF 或用 redis-cli —pipe 离线导入
  5. 导入完成后核对明细数量与计数值是否一致

注意事项:

  • 导入期间会占用 Redis CPU,建议低峰期执行并限速
  • 需要幂等:重复导入同一条记录不应重复计数

最终答案:

用 Redis Pipeline 批量导入:把上千条 SADD article:{id}:liked 和 INCRBY article:{id}:like_count 打包成一次网络往返提交,管道大小控制在 1000 条以内;数据量大时再分批提交。同时用 Lua 脚本把『加计数 + 加成员 + 判重』合成一个原子操作,避免导入过程中出现计数与明细不一致。

练习 5

如何实现”跨天”的点赞记录查询?

数据查询时间范围分片

解题思路:

这道题问的是查『某几天』范围内的点赞记录,核心是『用索引定位时间范围』而不是全表扫。

详细步骤:

方案:按日期分片存储

实现步骤:

  1. 存储侧按日期分片:
    • MySQL 用 RANGE 分区(按 created_at)
    • Redis 用 like:{article_id}:{yyyyMMdd} 这样的日粒度 key
  2. 建复合索引 (user_id, created_at) 或 (article_id, created_at)
  3. 查询时把日期条件写进 WHERE,由分区裁剪 + 索引扫描共同收敛范围
  4. 跨多天时按分区逐个查再归并,或用 UNION ALL

注意事项:

  • 分片粒度要与查询维度对齐,避免『按天分片但按月查』的扫描放大
  • 历史分片可以定期归档,缩短分区数量

最终答案:

按日期分片存储 + 合适的复合索引:点赞记录按 created_at 分区(MySQL 分区表,或按天拆成不同表/不同 key),并建 (user_id, created_at) 或 (article_id, created_at) 复合索引,查询跨天数据时先按日期范围裁剪分区,再在分区内走索引扫描,避免全表扫描。


思考题

  1. 如何设计一个支持”撤销”的点赞系统(可以撤销任意时间的点赞)?

  2. 如何实现”点赞提醒”(文章作者收到点赞通知)?

  3. 如何优化”超级用户”的 Feed 流存储(点赞数超过 10000)?

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

发现内容有问题?

告诉我们哪里需要改进。