技术方案
面对上一节梳理的挑战,我开始研究各种技术方案。
技术选型
我考虑了几种方案:
方案 A:纯数据库
优点:数据强一致性,实现简单
缺点:性能差,扛不住高并发
结论:放弃
方案 B:数据库 + 缓存
优点:查询性能好,实现相对简单
缺点:一致性问题,缓存更新策略复杂
结论:备选
方案 C:Redis 计数 + 异步同步到数据库
优点:性能最好,能扛高并发
缺点:实现复杂,需要考虑可靠性
结论:主力方案
我选择了方案 C:Redis 计数 + 异步同步。
我画出了整体架构:
┌─────────────┐
│ 用户请求 │
└──────┬──────┘
│
▼
┌─────────────────────────┐
│ 应用服务器 │
│ - 处理点赞/取消点赞 │
│ - 查询点赞状态 │
│ - 返回点赞数 │
└──────┬─────────┬────────┘
│ │
│ │
▼ ▼
┌──────────┐ ┌──────────────┐
│ Redis │ │ 数据库 │
│ - 计数器│ │ - 点赞记录 │
│ - 集合 │ │ - 用户数据 │
└────┬─────┘ └───────┬──────┘
│ │
└────────┬───────┘
│
▼
┌───────────────┐
│ 异步同步任务 │
│ - 定时同步 │
│ - 数据对账 │
└───────────────┘
数据结构设计
我在 Redis 中设计了两种数据结构:
1. 计数器(String)
Key: article:{article_id}:like_count
Value: 点赞数(整数)
操作: INCR / DECR / GET
示例:
article:123:like_count = 1000
2. 点赞集合(Set)
Key: article:{article_id}:liked_users
Value: 点赞过的用户 ID 集合
操作: SADD / SREM / SISMEMBER
示例:
article:123:liked_users = {1, 2, 3, 5, 8, 13, ...}
为什么需要两种结构?
计数器:
- 快速获取点赞总数
- O(1) 时间复杂度
点赞集合:
- 判断用户是否点赞
- O(1) 时间复杂度
- 支持集合操作
核心流程
点赞流程:
取消点赞流程:
查询点赞数流程:
查询是否点赞:
异步同步设计
为什么要异步同步到数据库?
原因:
1. Redis 数据在内存中,需要持久化
2. 数据库用于数据备份和复杂查询
3. 可以降低数据库写入压力
方式:
- 消息队列(RabbitMQ / Kafka)
- 定时任务(Celery)
异步同步流程:
问题:缓存和数据库不一致
场景:用户点赞
时序:
1. Redis 更新成功(INCR)
2. 发送异步消息
3. 消费者处理消息失败(数据库宕机)
结果:
- Redis 显示已点赞
- 数据库没有记录
→ 数据不一致!
解决方案 1:重试机制
重试机制解决的是”偶发的失败”:消费者处理消息时数据库正好抖动了一下,重试几次就能成功。
import time
import random
RETRY_DELAYS = [1, 2, 4, 8, 16] # 指数退避,单位秒
MAX_RETRIES = len(RETRY_DELAYS)
class SyncConsumer:
"""带重试的异步同步消费者"""
def __init__(self, db, redis_client):
self.db = db
self.redis = redis_client
def handle(self, message):
"""处理一条同步消息,失败时重试"""
article_id = message["article_id"]
delta = message["delta"]
attempt = 0
while True:
try:
self.db.apply_delta(article_id, delta)
return True
except (DatabaseError, ConnectionError) as e:
attempt += 1
if attempt > MAX_RETRIES:
# 重试耗尽,转入死信队列,不要无限重试
self.send_to_dead_letter(message, e)
return False
# 指数退避 + 随机抖动,避免大量消费者同时重试
delay = RETRY_DELAYS[attempt - 1] + random.uniform(0, 1)
logger.warning(
"sync retry %s/%s article=%s error=%s",
attempt, MAX_RETRIES, article_id, e,
)
time.sleep(delay)
def send_to_dead_letter(self, message, error):
"""死信队列:人工介入或后续批量修复"""
redis_client.lpush(
"sync:dead_letter",
json.dumps({"message": message, "error": str(error), "time": time.time()}),
)
重试必须配指数退避,不能立刻重试。
固定间隔重试:
T0 失败 → 立即重试 → 失败 → 立即重试 → 失败 → ...
→ 数据库还没恢复,5 次全部失败,白白消耗
指数退避:
T0 失败,等 1s
T1 失败,等 2s
T3 失败,等 4s
T7 失败,等 8s
T15 失败,等 16s
T31 超过最大重试次数 → 死信队列
→ 给数据库留出恢复时间,成功率显著提高
为什么要加随机抖动?
没有抖动:
数据库在 T0 短暂抖动
1000 个消费者同时在 T0 失败,同时在 T0+1 重试
→ 数据库刚要恢复就被 1000 个请求再次压垮 ❌
有抖动:
1000 个消费者的重试时间分散在 T0+1 到 T0+2 之间
→ 数据库有喘息的机会 ✅
重试的边界条件:
1. 哪些错误该重试?
可重试:连接超时、数据库死锁、网络错误、临时不可用
不可重试:唯一约束冲突、参数错误、业务规则不满足
→ 不可重试的错误直接进死信队列,不要浪费重试次数
2. 幂等性是前提
重试意味着"同一个操作被执行多次"
→ 写库必须幂等(用增量而不是绝对值,见《合并写入》)
3. 总重试次数要有上限
无限重试会把死信队列撑爆,同时掩盖真正的故障
重试机制解决不了”持续性失败”。
如果数据库宕机 10 分钟,所有重试都会失败,消息会堆积到死信队列。这时候靠重试是治不好的,需要的是熔断 + 降级 + 人工介入。
熔断器的思路:
连续失败 N 次(比如 10 次)→ 打开熔断器
熔断打开期间:不再调用数据库,直接把消息丢进死信队列
等待一段时间(比如 60 秒)→ 半开状态,放一条消息试探
试探成功 → 关闭熔断器,恢复正常
试探失败 → 重新打开熔断器
重试 + 死信队列 + 熔断器,三者配合才完整:
| 机制 | 处理的问题 |
|---|---|
| 重试(指数退避) | 偶发失败 |
| 死信队列 | 重试耗尽的失败 |
| 熔断器 | 持续失败时的自我保护 |
解决方案 2:数据对账
重试只能保证”最终会成功”,但不能保证”从来没失败过”。要发现历史遗留的不一致,需要定期对账。
def reconcile(db, redis_client, batch_size=500):
"""对账任务:比对 Redis 计数与数据库实际记录数,修复差异"""
checked = 0
fixed = 0
mismatches = []
# 用游标分页遍历所有文章
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
for row in rows:
last_id = row["id"]
article_id = row["id"]
checked += 1
# Redis 里的计数
redis_count = redis_client.get(f"article:{article_id}:like_count")
redis_count = int(redis_count) if redis_count is not None else 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))
# 以数据库为准修复 Redis(Redis 可以从数据库重建)
redis_client.set(f"article:{article_id}:like_count", db_count)
fixed += 1
if len(mismatches) >= 100:
# 差异太多,说明可能有系统性问题,告警而不是继续修
alert(f"对账发现 {len(mismatches)} 处不一致,疑似系统性故障")
break
return {"checked": checked, "fixed": fixed, "mismatches": mismatches}
对账的核心逻辑:以数据库为准修复 Redis。
为什么以数据库为准,而不是以 Redis 为准?
因为:
- Redis 可以从数据库重建(把 Redis 清空再灌一遍就行)
- 数据库是持久化的最终真值
- 数据库的 COUNT 是"点赞记录"的绝对事实
所以:Redis 错了 → 改 Redis。数据库错了 → 那要人工介入。
但全量 COUNT 是很重的操作。
10 万篇文章 × 每篇一次 COUNT(*) = 10 万次全表扫描
→ 一次对账可能要跑几个小时
优化办法:抽样对账 + 增量对账。
1. 抽样对账(日常)
每次只查 1000 篇文章(随机或按 id 取模)
→ 几分钟跑完,能发现大部分问题
2. 全量对账(低峰期)
每天凌晨跑一次全量
3. 只对比"可疑文章"
比如:最近有写入的、Redis 操作有错误的、用户投诉过的
对账的另一个思路:用增量对账代替 COUNT。
维护一张"变更流水"表:
article_likes_delta(article_id, delta, created_at)
对账时:
Redis 计数 vs SUM(delta) 的累计值
→ 不需要 COUNT 全表,只需要扫描增量表
→ 增量表可以定期归档,只保留最近 N 天
对账的产出不只是”修复”,还有”可观测性”。
对账报告应该包含:
- 检查了多少篇文章
- 发现多少处不一致
- 不一致率(这是核心指标)
- 不一致的分布(是集中在某段时间?还是某几篇文章?)
- 每处不一致的差值大小(差 1 说明是丢消息,差 10000 说明是数据损坏)
不一致率是最重要的监控指标。
不一致率 = 不一致文章数 / 检查文章数
目标:< 0.1%
如果突然飙升 → 说明同步链路出问题了 → 立即告警
对账任务本身也要考虑对业务的影响。
1. 限速
每秒最多处理 N 篇,不要把数据库打满
→ 对账任务绝不能影响线上业务
2. 分片并行
按 article_id % K 分给 K 个 worker 并行
3. 只读为主
对账主要做 SELECT,只有确认不一致时才写 Redis
对账和重试是互补的:
重试:处理"现在正在失败"的同步,保证最终一致
对账:发现"过去失败过"的同步,修复历史遗留问题
对账任务的存在,让重试机制的失败不再可怕:
重试全部失败 → 消息在死信队列 → 人工修复 + 下次对账兜底
解决方案 3:最终一致性
一致性级别:
强一致性:
- 用户体验最好
- 性能最差
- 实现复杂
弱一致性:
- 性能最好
- 用户体验差
- 数据可能丢失
最终一致性:
- 性能好
- 用户体验可接受
- 数据最终会一致
我选择了最终一致性。
原因:
- 点赞数稍微延迟更新,用户可以接受
- 通过对账机制,保证数据最终一致
- 性能和用户体验的平衡
批量查询
性能提升:
- 优化前:20 次网络往返
- 优化后:2 次网络往返(pipeline)
- 性能提升:10 倍
本地缓存
注意:本地缓存可能导致数据延迟,需要权衡。
Redis 故障处理
场景:Redis 宕机
降级策略:
1. 尝试连接 Redis
2. 如果连接失败,直接查询数据库
3. 返回结果,但性能下降
代码示例:
def get_like_count_with_fallback(article_id):
try:
return redis.get(f"article:{article_id}:like_count")
except RedisConnectionError:
# 降级:查询数据库
return db.query(
"SELECT COUNT(*) FROM article_likes WHERE article_id = ?",
article_id
)[0]['count']
数据备份策略
Redis 数据:
- RDB 快照(每小时)
- AOF 日志(实时)
数据库数据:
- 主从复制
- 每日备份
异步消息队列:
- 消息持久化
- 死信队列
实施新方案后,我观察了一周的数据:
性能指标
| 指标 | 优化前 | 优化后 | 提升 |
|---|---|---|---|
| 查询响应时间 | 800ms | 5ms | 160 倍 |
| 数据库 QPS | 3200 | 150 | 降低 95% |
| Redis QPS | - | 3000 | 新增 |
| 缓存命中率 | 60% | 99% | +65% |
| 并发处理能力 | 100/秒 | 5000/秒 | 50 倍 |
可靠性指标
| 指标 | 值 |
|---|---|
| 数据一致性 | 99.9%(通过对账) |
| 系统可用性 | 99.95% |
| 故障恢复时间 | < 5 分钟 |
业务指标
| 指标 | 优化前 | 优化后 |
|---|---|---|
| 用户投诉 | 3 条/周 | 0 条/周 |
| 点赞成功率 | 95% | 99.9% |
| 页面加载速度 | 3s | 0.5s |
效果显著!
练习 1
Redis 中 INCR 命令的时间复杂度是多少?为什么?
解题思路:
这道题问的是 INCR 的复杂度及其来源,要先给出结论,再从『内存操作 + 单线程 + 无锁』三点解释,并和数据库的 COUNT 做对比说明工程意义。
详细步骤:
答案:O(1),常数时间复杂度。
原因:
- Redis 是基于内存的存储
- 计数器存储为字符串类型,直接在内存中进行整数加减运算
- 不需要遍历数据结构,直接定位到 key 并执行操作
- 单线程执行,无锁竞争开销
对比 MySQL COUNT 查询:
- MySQL COUNT: O(n),需要扫描索引或表
- Redis INCR: O(1),直接操作内存
这也是为什么 Redis 适合做计数器的原因。
最终答案:
INCR 的时间复杂度是 O(1)。原因有三:Redis 是内存存储,计数器以字符串形式直接定位到 key 并做整数加减,不需要遍历任何集合;命令在单线程中顺序执行,不存在锁竞争与上下文切换开销。对比 MySQL 的 COUNT 需要扫描索引或表(O(n)),这正是 Redis 适合做计数器的根本原因。
练习 2
如何解决缓存和数据库的一致性问题?请列举至少三种方案。
解题思路:
这道题问的是缓存一致性的可选方案,要先把『谁先写、谁后写、失败怎么办』这三条判定轴列出来,再套到四个经典模式上,最后横向对比。
详细步骤:
常见方案:
方案一:Cache Aside Pattern(旁路缓存)
方案二:Write Through(写穿透)
方案三:Write Behind(异步写入)
方案四:双写一致性(分布式锁)
各方案对比:
| 方案 | 一致性 | 性能 | 实现复杂度 |
|---|---|---|---|
| Cache Aside | 最终一致 | 中 | 低 |
| Write Through | 强一致 | 低 | 中 |
| Write Behind | 最终一致 | 高 | 高 |
| 分布式锁 | 强一致 | 低 | 高 |
最终答案:
四种经典方案:Cache Aside(先更新数据库再删缓存,最终一致、实现最简单)、Write Through(缓存层代理写库,强一致但性能下降)、Write Behind(异步批量落库,性能最高但最终一致)、分布式锁双写(强一致但复杂且有性能损耗)。一般业务首选 Cache Aside;点赞这类读多写少、可容忍短暂不一致的场景用 Cache Aside 或 Write Behind,配合定期对账兜底。
练习 3
设计一个点赞去重的方案,防止用户重复点赞。
解题思路:
这道题问的是去重『在哪一层做』,要按可靠性与性能把数据库唯一索引、Redis SET、双重保证三条路排出来,最后说明各自的取舍。
详细步骤:
方案一:数据库唯一索引
数据设计要点
- 核心是在
article_likes里保存业务事实,而不是把规则散落在应用逻辑里。- 索引服务于高频查询,重点是缩小扫描范围,而不是堆更多字段。
- 关键字段包括
article_id、user_id、created_at,它们决定后续查询和管理能力。
优点:数据层保证唯一性 缺点:依赖数据库,性能较差
方案二:Redis SET 去重
优点:性能高,O(1) 复杂度 缺点:Redis 故障时可能失效
方案三:Redis + 数据库双重保证
优点:双重保证,最可靠 缺点:实现复杂
最终答案:
三层方案:数据库唯一索引(article_likes 上 (article_id, user_id) 唯一键)由数据层兜底,最可靠但每次写入都要走 DB;Redis SET 去重(SADD article:{id}:liked),O(1) 性能高但 Redis 故障时会失效;Redis + 数据库双重保证,先用 Redis 挡掉绝大多数重复请求,异步或校验时再落库。最稳妥的是双重保证——Redis 负责挡量、数据库负责兜底。
练习 4
如何实现”点赞排行榜”功能?列出 Top 10 点赞最多的文章。
解题思路:
这道题问的是排行榜用什么数据结构支撑,要先看 ZSET 的排序与复杂度特性,再补上生产环境真正会遇到的容量与实时性优化。
详细步骤:
方案:使用 Redis Sorted Set(有序集合)
Redis Sorted Set 特性:
- 自动按分数排序
- O(log N) 插入和更新复杂度
- O(log N) 查询复杂度
优化建议:
- 只保留 Top N,定期清理:
ZREMRANGEBYRANK article:like_ranking 0 -1001 - 使用定时任务更新排行榜,而不是实时更新
- 考虑分页查询:
ZREVRANGE key start stop
最终答案:
用 Redis Sorted Set:key 为 article:like_ranking,member 是 article_id、score 是点赞数,ZINCRBY 累加、ZREVRANGE ... WITHSCORES 取 Top 10,复杂度 O(log N + M)。生产上要配合三点优化:只保留 Top N(ZREMRANGEBYRANK key 0 -1001)、用定时任务批量刷新排行榜而不是每次实时写、分页查询用 ZREVRANGE key start stop。
练习 5
如果用户在 1 秒内快速点击 10 次点赞按钮,如何处理?
解题思路:
这道题问的是『连点』造成的重复请求与状态翻转,要分前端拦截、后端限流、幂等兜底三层来答。
详细步骤:
方案一:前端防抖
方案二:后端限流
方案三:幂等性设计
推荐方案:
- 前端防抖 + 后端幂等性设计
- 限制 1 秒内只能点赞/取消点赞一次
- 多次点击幂等处理
问题本质:
- 10 次点击可能产生 10 个请求
- 若逻辑是『点击即切换状态』,会变成点赞→取消→点赞的翻转
- 若逻辑是『只累加』,则会多计 9 次
三层防护:
- 前端:按钮点击后置灰 500ms~1s,或用 throttle/debounce 做防抖
- 后端限流:Redis 令牌桶限制『同一用户 + 同一文章』1 秒 1 次
- 幂等兜底:请求携带幂等键或直接依赖唯一索引 +
SET NX,重复请求返回相同结果
注意:
- 前端防抖可以被绕过(抓包重放),不能作为唯一保障
- 限流阈值要区分『取消点赞』和『点赞』两个方向
最终答案:
三层防护:前端加防抖/节流,1 秒内的连续点击只发一次请求;后端对同一用户同一文章做限流(1 秒内只允许一次点赞/取消);最关键的是幂等设计——用唯一索引或 SET NX 让重复请求返回同一个结果而不是重复计数。推荐前端防抖 + 后端幂等兜底:前端防抖可以被绕过,幂等才是最终保证。
-
如果 Redis 内存不足,如何优化点赞数据的存储?
-
如何实现”点赞用户列表”功能?显示点赞过某篇文章的所有用户。
-
如果平台增长到千万级用户,如何设计计数系统的架构?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
