分片计数


新的瓶颈

Redis 方案上线后,系统运行良好。

直到有一天,平台推出了一位知名作者的新文章。

数据飙升:

文章发布时间:20:00
发布后 1 小时:50000 阅读,5000 点赞
发布后 2 小时:100000 阅读,12000 点赞
发布后 3 小时:200000 阅读,25000 点赞

峰值:每秒约 100 个点赞请求!

系统监控:

Redis 状态:
- CPU:45%
- 内存:正常
- QPS:约 8000

单个热门文章:
- article:123:like_count
- 每秒 INCR 操作:约 100 次
- 单 key 竞争严重

虽然 Redis 能扛住,但单个 key 的竞争太严重了!


问题分析

场景:爆款文章

问题:
1. 所有用户点赞同一篇文章
2. 都在操作同一个 Redis key
3. 单个 Redis 实例成为瓶颈

影响:
- 单 key 访问频率高
- 可能导致热 key 问题
- 分布式锁竞争

解决方案:分片计数(Sharded Counter)


分片计数原理

核心思想:

  • 将计数器分散到多个 key
  • 每个 shard 独立计数
  • 查询时合并所有 shard 的值

示意图:

原来:
article:123:like_count = 1000

分片后:
article:123:like_count:0 = 250
article:123:like_count:1 = 250
article:123:like_count:2 = 250
article:123:like_count:3 = 250

总计:1000

实现方案

基础实现

分片计数的实现只有三步:选分片 → 原子自增 → 求和读取。

import hashlib


class ShardedCounter:
    """分片计数器:把计数分散到多个 key,读取时求和"""

    def __init__(self, redis_client, shard_count=10):
        self.redis = redis_client
        self.shard_count = shard_count

    def _shard_key(self, article_id, shard):
        return f"article:{article_id}:like_count:{shard}"

    def _pick_shard(self, article_id, user_id):
        """按 user_id 选分片:同一个用户总是落在同一个分片上"""
        digest = hashlib.md5(f"{article_id}:{user_id}".encode()).hexdigest()
        return int(digest, 16) % self.shard_count

    def incr(self, article_id, user_id, delta=1):
        """自增:只碰一个 key,天然分散热点"""
        shard = self._pick_shard(article_id, user_id)
        key = self._shard_key(article_id, shard)
        if delta >= 0:
            return int(self.redis.incrby(key, delta))
        return int(self.redis.decrby(key, -delta))

    def get_count(self, article_id):
        """求和:一次 MGET 取回所有分片再相加"""
        keys = [self._shard_key(article_id, i) for i in range(self.shard_count)]
        values = self.redis.mget(keys)
        return sum(int(v) for v in values if v is not None)

    def get_counts(self, article_ids):
        """批量读取多篇文章:一次 MGET 取回所有 key"""
        keys = []
        for article_id in article_ids:
            for i in range(self.shard_count):
                keys.append(self._shard_key(article_id, i))
        values = self.redis.mget(keys)

        counts = {aid: 0 for aid in article_ids}
        index = 0
        for article_id in article_ids:
            total = 0
            for _ in range(self.shard_count):
                raw = values[index]
                index += 1
                if raw is not None:
                    total += int(raw)
            counts[article_id] = total
        return counts

三个设计要点:

1. 按 user_id 而不是按 article_id 选分片。

按 article_id 选:
    所有用户点赞文章 123 → 全落到同一个分片 ❌ 等于没分片

按 user_id 选:
    用户 A → 分片 0
    用户 B → 分片 1
    用户 C → 分片 2
    ... ✅ 热点被打散

注意:分片是按 (article_id, user_id) 组合哈希的。

如果只按 user_id 哈希,那么同一个用户点赞不同文章时会落在同一个分片上——这个用户就变成了新的热点。带上 article_id 可以避免这一点。

2. 计数永远落在”当前分片数”对应的 key 上。

写路径用 self.shard_count 计算分片号,读路径也用同一个值取 key。只要两边一致就不会读错。

3. 求和读取用一次 MGET,不要循环 GET。

循环 GET:  10 个分片 = 10 次网络往返
一次 MGET:  10 个分片 = 1 次网络往返

这是分片计数的主要代价:写变快了,读变贵了。从 1 次往返变成 N 次(虽然用 MGET 压缩成 1 次,但服务端要处理 N 个 key)。

分片计数的读取一致性问题:

求和不是原子的。读取 10 个分片的过程中可能有分片正在被修改:

T1: 读 shard 0 → 100
T2: 读 shard 1 → 100
T3: 用户点赞 shard 0 → 101
T4: 读 shard 2 → 100
...
合计 = 1001,但真实值可能是 1002

误差范围是”读取窗口内的并发写入数”,通常在个位数。如果业务要求精确,需要用 Lua 脚本在服务端求和,见《Lua 脚本》一章。

优化:动态分片数量

分片数写死在配置里,一旦线上流量涨了或者跌了,就很被动。动态分片的核心难题是:改分片数不能破坏已有的 key。

问题:
当前 10 个分片:
    article:123:like_count:0 = 250
    article:123:like_count:1 = 250
    ...
    article:123:like_count:9 = 250

改成 20 个分片后:
    article:123:like_count:10  ← 这个 key 从来没被用过
    原来 0~9 的数据还分散在老 key 里

如果直接切换分片数,老 key 里的数据会被彻底遗弃——计数从 250 变成 0。

解法一:双写过渡期(最简单)

class MigratingShardedCounter:
    """分片数迁移:过渡期同时写新旧两套 key"""

    def __init__(self, redis_client, old_shard_count=10, new_shard_count=20):
        self.redis = redis_client
        self.old_shard_count = old_shard_count
        self.new_shard_count = new_shard_count
        self.migrating = True        # 迁移开关

    def incr(self, article_id, user_id, delta=1):
        # 新分片:按新的分片数写入
        new_shard = self._pick_shard(article_id, user_id, self.new_shard_count)
        new_key = f"article:{article_id}:like_count:{new_shard}"
        self.redis.incrby(new_key, delta)

        # 迁移期:老分片也要写,保证老数据不丢
        if self.migrating:
            old_shard = self._pick_shard(article_id, user_id, self.old_shard_count)
            old_key = f"article:{article_id}:like_count:{old_shard}"
            self.redis.incrby(old_key, delta)

    def get_count(self, article_id):
        """读取:过渡期两套都读,取最大值避免重复计数"""
        new_total = self._sum_shards(article_id, self.new_shard_count)
        if not self.migrating:
            return new_total

        old_total = self._sum_shards(article_id, self.old_shard_count)
        return max(new_total, old_total)

取 max 而不是相加:迁移期两套 key 记录的是同一批点赞,相加会把数字翻倍。取较大的那个更接近真实值。

双写的代价:写放大 2 倍。 所以过渡期要尽量短。

解法二:数据迁移(更干净)

class ShardMigrator:
    """在线迁移:把老分片的数据合并到新分片"""

    def migrate_article(self, article_id):
        """迁移单篇文章的分片数据"""
        old_keys = [f"article:{article_id}:like_count:{i}"
                    for i in range(self.old_shard_count)]
        old_values = self.redis.mget(old_keys)
        old_total = sum(int(v) for v in old_values if v is not None)

        if old_total == 0:
            return 0

        # 把老分片的总量写进新分片
        new_shard = self._pick_shard(article_id, self.article_id_seed(article_id),
                                     self.new_shard_count)
        new_key = f"article:{article_id}:like_count:{new_shard}"
        self.redis.set(new_key, old_total)

        # 确认新值写入成功后,再删老 key
        if int(self.redis.get(new_key) or 0) == old_total:
            self.redis.delete(*old_keys)
            return old_total
        return 0

迁移的安全顺序很重要:

1. 先把老分片的总量写到新 key        ← 读新 key 的服务先看到新数据
2. 校验新 key 的值正确
3. 再删除老 key                    ← 最后才删,保证随时可回退

顺序反了就会出现”老 key 删了、新 key 还没写”的空窗,计数会瞬间归零。

迁移期间怎么保证一致性?

方案做法适用
双写新旧两套同时写,读时取 max迁移窗口短、追求简单
停写迁移短暂停写,迁完再放开可以接受秒级暂停
在线迁移按 key 逐个迁,迁完一个删一个大规模、不能停写

还有一个更省事的思路:分片数只增不减,且读写都用”最大分片数”。

方案:分片数由全局配置控制,所有实例读同一份配置

配置从 10 改成 20 的瞬间:
    写路径立刻按 20 个分片写
    读路径按 20 个分片读
    原来 0~9 分片里的数据已经"漂移"了 ❌

这个方案不成立——因为哈希取模的结果和分片数绑定,分片数一变,同一个用户就会被映射到新的分片,老分片的数据就成了孤儿。

所以动态分片必须配合数据迁移或双写,没有捷径。

什么时候该扩分片?

判断依据:
- 单个 key 的 INCR QPS 持续超过 1 万
- Redis CPU 持续超过 60%
- 热门文章的 P99 延迟开始抖动

分片数估算:
    shard_count = 峰值写入 QPS / 每个分片的目标 QPS
    目标 QPS 取 1000 ~ 5000(见《分片计数》课后练习的推荐表)

性能对比

场景:10,000 个并发用户点赞同一篇文章

不分片:
- 热点 key:article:123:like_count
- 单 key INCR QPS:10,000
- 响应时间:P50 0.3ms / P99 12ms
- Redis CPU:78%

分片(10 个 shard):
- 分散到 10 个 key
- 单 key INCR QPS:1,000
- 响应时间:P50 0.1ms / P99 1.5ms
- Redis CPU:21%
方案写延迟(P99)单 key QPSRedis CPU读成本
不分片12ms10,00078%1 次 GET
10 分片1.5ms1,00021%1 次 MGET(10)
50 分片0.8ms20012%1 次 MGET(50)

分片数不是越多越好。

分片数 ↑  →  写延迟 ↓(热点更分散)
           →  读延迟 ↑(求和要读更多 key)
           →  内存 ↑(key 数量变多,每个 key 都有固定开销)
           →  运维 ↑(迁移、监控、清理都更复杂)

读多写少的场景,分片要少;写多读少的场景,分片要多。 点赞计数属于写多读少,10~50 是比较合适的区间。

批量读是分片计数最值得优化的地方。

逐篇读取(每篇一次 MGET):
    20 篇文章 = 20 次 MGET

一次 MGET 取回所有 key:
    20 篇文章 × 10 分片 = 200 个 key,一次 MGET 取回
    服务端再按文章归组求和

上面 get_counts() 就是这个思路。Feed 流列表页一定要用这种方式,否则 N+1 会把收益全部吃掉。


实际效果

性能提升

场景:爆款文章,每秒 100 次点赞

不分片:
- 单 key 竞争严重
- Redis CPU:45%
- 响应时间:波动较大

分片(10 个 shard):
- 分散到 10 个 key
- Redis CPU:15%
- 响应时间:稳定

提升:
- 性能提升 3 倍
- 响应时间更稳定

课后练习

练习 1

分片计数器如何保证数据一致性?

Redis分片一致性

解题思路:

这道题问的是分片后『总数 = 各分片之和』这个等式在并发读写下如何成立,要先定位不一致窗口出现在跨分片读取这个动作上。

详细步骤:

问题分析:

场景:用户点赞

分片后:
- 用户 A 的点赞记录在 shard 0
- 用户 B 的点赞记录在 shard 1
- ...

查询总数:
- 需要合并所有 shard
- 可能存在时间窗口不一致

示例:
T1: 查询 shard 0 → 100
T2: 查询 shard 1 → 100
T3: 用户点赞 shard 0 → 101
T4: 查询 shard 2 → 100
...
T10: 用户点赞 shard 1 → 101

合并结果:
- shard 0: 101(新值)
- shard 1: 100(旧值)
- shard 2: 100
- ...
总计:1001(不准确!)

解决方案:

方案 1:使用 Pipeline 原子查询

方案 2:定期合并

方案 3:使用 Lua 脚本

原子操作要点

  • 这里关注的是把读取、判断和更新合成一个不可打断的状态变化,而不是记住脚本语法。

最终答案:

分片计数的一致性问题出现在读取总数时——不同分片在不同时刻被读,会合并出偏大或偏小的总数。可用三种手段收敛:Pipeline 把所有分片的 GET 打成一次往返以缩小窗口、后台定期把分片合并成汇总值对外提供、Lua 脚本把跨分片的读或写合成一个原子操作。实践上『分片写 + 汇总键读 + 定期合并』是性价比最高的组合。

练习 2

如何选择合适的分片数量?

分片性能优化架构设计

解题思路:

这道题问的是分片数怎么定,要先找出真正约束分片数的四个因素,再把因素换算成可查的指标(并发量、数据量、合并代价、运维复杂度),最后查表取值。

详细步骤:

分片数量选择原则:

因素 1:并发量
- 并发量越大,分片数越多
- 每个 shard 理想 QPS:1000 ~ 5000

因素 2:数据量
- 数据量越大,分片数越多
- 每个 shard 理想数据量:10MB ~ 100MB

因素 3:查询性能
- 分片数越多,查询越慢(需要合并)
- 需要平衡读写性能

因素 4:运维成本
- 分片数越多,运维越复杂

计算公式:

建议值:

场景QPS数据量推荐分片数
低并发< 1000< 10MB5 ~ 10
中并发1000 ~ 1000010MB ~ 100MB10 ~ 20
高并发10000 ~ 50000100MB ~ 500MB20 ~ 50
超高并发> 50000> 500MB50 ~ 100

最终答案:

分片数由四个因素共同决定:并发量(每个分片理想 10005000 QPS)、数据量(每个分片 10100MB)、查询性能(分片越多,合并总计数越慢)、运维成本(分片越多,扩容与排查越复杂)。据此的建议值是:低并发 510 个、中并发 1020 个、高并发 2050 个、超高并发 50100 个。实际取值应让每个分片的负载落在理想区间内,并预留一倍余量以便在线扩容。

练习 3

分片计数器如何支持”点赞用户列表”功能?

Redis分片数据结构

解题思路:

这道题问的是计数分片之后『谁点赞了』这份明细数据放在哪里,答案是明细要跟着计数一起分片。

详细步骤:

方案:点赞集合也分片

设计要点:

  1. 分片键与计数器一致:同一篇文章的计数和用户集合用同样的分片规则
  2. 写入路径:SADD 只写用户命中的那一个分片,O(1)
  3. 读取路径:合并所有分片的成员,必要时用 SSCAN 分批拉取
  4. 内存估算:一个用户一个成员,100 万点赞约占用数十 MB,需要评估

注意事项:

  • 用户到分片的映射必须用稳定哈希,不能用随机值
  • 若需要『某人赞过哪些文章』,要另建按用户分片的反向索引

最终答案:

点赞用户列表用分片集合承载:为每篇文章建立 N 个 Set,把用户按哈希映射到固定分片(如 article:{id}:liked:{shard}),写入时只碰用户所属的那一个分片;读取列表时合并各分片的成员即可。分片数要与计数器保持一致,用户到分片的映射必须使用同一个哈希函数,避免读写落到不同分片。

练习 4

分片计数器如何支持”排行榜”功能?

Redis分片排行榜

解题思路:

这道题问的是『分片计数 + 排行榜』能不能共存,答案是把排行榜也按同样的规则分片成多个 ZSET。

详细步骤:

方案:使用 ZSET 分片

实现步骤:

  1. 每篇文章在每个分片上建一个 ZSET:rank:{article_id}:{shard}
  2. 点赞用 ZINCRBY 累加到用户命中的分片,O(log N)
  3. 查询时对每个分片各取 Top N,再在应用层合并排序取前 N
  4. 定期归并:把分片数据合并进汇总 ZSET,并清理已过期的分片

注意事项:

  • 合并时的取数范围至少要覆盖全局 Top N,分片数多时合并成本上升
  • 取消点赞用 ZINCRBY 负数,注意分数可能变负

最终答案:

排行榜用分片 ZSET 实现:每篇文章在每个分片上各维护一个 ZSET,用户的点赞与取消以 ZINCRBY 原子地累加到所属分片;查询 Top N 时合并各分片的 Top N 再取全局前 N。分片数量与计数器保持一致,并需要定期把分片结果归并、清理冷数据。

练习 5

分片计数器如何实现”数据迁移”?

数据迁移分片运维

解题思路:

这道题问的是分片数要扩容时,已有的分片数据怎么搬到新分片里去,核心是『迁移期间新旧分片同时对外服务』。

详细步骤:

场景:增加分片数量

当前:10 个 shard
目标:20 个 shard

问题:如何迁移数据?

方案:在线迁移

迁移步骤:

  1. 扩容前固定分片路由配置,确定新旧分片的对应关系
  2. 双写:新写入同时落到旧分片和新分片,保证两边数据齐平
  3. 回填:后台任务按主键范围批量扫描旧分片,把存量数据搬到新分片
  4. 校验:比对每个分片的计数和明细数量,确认一致
  5. 切换:把读请求切到新分片,观察一段时间
  6. 下线:停止双写,确认旧分片无流量后再释放

注意事项:

  • 回填要限速,不能打满 IO
  • 迁移期间对外提供的总数应为『旧分片合计 + 新分片合计』的并集去重结果

最终答案:

用在线迁移:先把新分片挂进路由但权重为 0,新旧分片同时写入(双写或『写新 + 回填旧』),后台任务把旧分片的存量数据分批扫描搬到新分片,校验每片计数一致后再把读流量逐步切到新分片,最后下线旧分片。全程服务不中断,对外提供的总数是旧分片合计与新分片合计的并集去重结果。


思考题

  1. 如果分片数选择不当,会有什么问题?

  2. 如何实现”动态分片”,根据负载自动调整分片数量?

  3. 分片计数器在分布式环境下如何保证一致性?

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

发现内容有问题?

告诉我们哪里需要改进。