分片计数
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 QPS | Redis CPU | 读成本 |
|---|---|---|---|---|
| 不分片 | 12ms | 10,000 | 78% | 1 次 GET |
| 10 分片 | 1.5ms | 1,000 | 21% | 1 次 MGET(10) |
| 50 分片 | 0.8ms | 200 | 12% | 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
分片计数器如何保证数据一致性?
解题思路:
这道题问的是分片后『总数 = 各分片之和』这个等式在并发读写下如何成立,要先定位不一致窗口出现在跨分片读取这个动作上。
详细步骤:
问题分析:
场景:用户点赞
分片后:
- 用户 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 | < 10MB | 5 ~ 10 |
| 中并发 | 1000 ~ 10000 | 10MB ~ 100MB | 10 ~ 20 |
| 高并发 | 10000 ~ 50000 | 100MB ~ 500MB | 20 ~ 50 |
| 超高并发 | > 50000 | > 500MB | 50 ~ 100 |
最终答案:
分片数由四个因素共同决定:并发量(每个分片理想 10005000 QPS)、数据量(每个分片 10100MB)、查询性能(分片越多,合并总计数越慢)、运维成本(分片越多,扩容与排查越复杂)。据此的建议值是:低并发 510 个、中并发 1020 个、高并发 2050 个、超高并发 50100 个。实际取值应让每个分片的负载落在理想区间内,并预留一倍余量以便在线扩容。
练习 3
分片计数器如何支持”点赞用户列表”功能?
解题思路:
这道题问的是计数分片之后『谁点赞了』这份明细数据放在哪里,答案是明细要跟着计数一起分片。
详细步骤:
方案:点赞集合也分片
设计要点:
- 分片键与计数器一致:同一篇文章的计数和用户集合用同样的分片规则
- 写入路径:SADD 只写用户命中的那一个分片,O(1)
- 读取路径:合并所有分片的成员,必要时用 SSCAN 分批拉取
- 内存估算:一个用户一个成员,100 万点赞约占用数十 MB,需要评估
注意事项:
- 用户到分片的映射必须用稳定哈希,不能用随机值
- 若需要『某人赞过哪些文章』,要另建按用户分片的反向索引
最终答案:
点赞用户列表用分片集合承载:为每篇文章建立 N 个 Set,把用户按哈希映射到固定分片(如 article:{id}:liked:{shard}),写入时只碰用户所属的那一个分片;读取列表时合并各分片的成员即可。分片数要与计数器保持一致,用户到分片的映射必须使用同一个哈希函数,避免读写落到不同分片。
练习 4
分片计数器如何支持”排行榜”功能?
解题思路:
这道题问的是『分片计数 + 排行榜』能不能共存,答案是把排行榜也按同样的规则分片成多个 ZSET。
详细步骤:
方案:使用 ZSET 分片
实现步骤:
- 每篇文章在每个分片上建一个 ZSET:
rank:{article_id}:{shard} - 点赞用 ZINCRBY 累加到用户命中的分片,O(log N)
- 查询时对每个分片各取 Top N,再在应用层合并排序取前 N
- 定期归并:把分片数据合并进汇总 ZSET,并清理已过期的分片
注意事项:
- 合并时的取数范围至少要覆盖全局 Top N,分片数多时合并成本上升
- 取消点赞用 ZINCRBY 负数,注意分数可能变负
最终答案:
排行榜用分片 ZSET 实现:每篇文章在每个分片上各维护一个 ZSET,用户的点赞与取消以 ZINCRBY 原子地累加到所属分片;查询 Top N 时合并各分片的 Top N 再取全局前 N。分片数量与计数器保持一致,并需要定期把分片结果归并、清理冷数据。
练习 5
分片计数器如何实现”数据迁移”?
解题思路:
这道题问的是分片数要扩容时,已有的分片数据怎么搬到新分片里去,核心是『迁移期间新旧分片同时对外服务』。
详细步骤:
场景:增加分片数量
当前:10 个 shard
目标:20 个 shard
问题:如何迁移数据?方案:在线迁移
迁移步骤:
- 扩容前固定分片路由配置,确定新旧分片的对应关系
- 双写:新写入同时落到旧分片和新分片,保证两边数据齐平
- 回填:后台任务按主键范围批量扫描旧分片,把存量数据搬到新分片
- 校验:比对每个分片的计数和明细数量,确认一致
- 切换:把读请求切到新分片,观察一段时间
- 下线:停止双写,确认旧分片无流量后再释放
注意事项:
- 回填要限速,不能打满 IO
- 迁移期间对外提供的总数应为『旧分片合计 + 新分片合计』的并集去重结果
最终答案:
用在线迁移:先把新分片挂进路由但权重为 0,新旧分片同时写入(双写或『写新 + 回填旧』),后台任务把旧分片的存量数据分批扫描搬到新分片,校验每片计数一致后再把读流量逐步切到新分片,最后下线旧分片。全程服务不中断,对外提供的总数是旧分片合计与新分片合计的并集去重结果。
-
如果分片数选择不当,会有什么问题?
-
如何实现”动态分片”,根据负载自动调整分片数量?
-
分片计数器在分布式环境下如何保证一致性?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
