技术方案


方案探索

面对上一节梳理的挑战,我开始研究各种技术方案。

技术选型

我考虑了几种方案:

方案 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 日志(实时)

数据库数据:
- 主从复制
- 每日备份

异步消息队列:
- 消息持久化
- 死信队列

效果评估

实施新方案后,我观察了一周的数据:

性能指标

指标优化前优化后提升
查询响应时间800ms5ms160 倍
数据库 QPS3200150降低 95%
Redis QPS-3000新增
缓存命中率60%99%+65%
并发处理能力100/秒5000/秒50 倍

可靠性指标

指标值
数据一致性99.9%(通过对账)
系统可用性99.95%
故障恢复时间< 5 分钟

业务指标

指标优化前优化后
用户投诉3 条/周0 条/周
点赞成功率95%99.9%
页面加载速度3s0.5s

效果显著!


课后练习

练习 1

Redis 中 INCR 命令的时间复杂度是多少?为什么?

Redis时间复杂度性能

解题思路:

这道题问的是 INCR 的复杂度及其来源,要先给出结论,再从『内存操作 + 单线程 + 无锁』三点解释,并和数据库的 COUNT 做对比说明工程意义。

详细步骤:

答案:O(1),常数时间复杂度。

原因:

  1. Redis 是基于内存的存储
  2. 计数器存储为字符串类型,直接在内存中进行整数加减运算
  3. 不需要遍历数据结构,直接定位到 key 并执行操作
  4. 单线程执行,无锁竞争开销

对比 MySQL COUNT 查询:

  • MySQL COUNT: O(n),需要扫描索引或表
  • Redis INCR: O(1),直接操作内存

这也是为什么 Redis 适合做计数器的原因。

最终答案:

INCR 的时间复杂度是 O(1)。原因有三:Redis 是内存存储,计数器以字符串形式直接定位到 key 并做整数加减,不需要遍历任何集合;命令在单线程中顺序执行,不存在锁竞争与上下文切换开销。对比 MySQL 的 COUNT 需要扫描索引或表(O(n)),这正是 Redis 适合做计数器的根本原因。

练习 2

如何解决缓存和数据库的一致性问题?请列举至少三种方案。

Redis数据一致性系统设计

解题思路:

这道题问的是缓存一致性的可选方案,要先把『谁先写、谁后写、失败怎么办』这三条判定轴列出来,再套到四个经典模式上,最后横向对比。

详细步骤:

常见方案:

方案一: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去重并发控制

解题思路:

这道题问的是去重『在哪一层做』,要按可靠性与性能把数据库唯一索引、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 点赞最多的文章。

Redis排行榜ZSet

解题思路:

这道题问的是排行榜用什么数据结构支撑,要先看 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 次点赞按钮,如何处理?

Redis防抖并发控制

解题思路:

这道题问的是『连点』造成的重复请求与状态翻转,要分前端拦截、后端限流、幂等兜底三层来答。

详细步骤:

方案一:前端防抖

方案二:后端限流

方案三:幂等性设计

推荐方案:

  • 前端防抖 + 后端幂等性设计
  • 限制 1 秒内只能点赞/取消点赞一次
  • 多次点击幂等处理

问题本质:

  • 10 次点击可能产生 10 个请求
  • 若逻辑是『点击即切换状态』,会变成点赞→取消→点赞的翻转
  • 若逻辑是『只累加』,则会多计 9 次

三层防护:

  1. 前端:按钮点击后置灰 500ms~1s,或用 throttle/debounce 做防抖
  2. 后端限流:Redis 令牌桶限制『同一用户 + 同一文章』1 秒 1 次
  3. 幂等兜底:请求携带幂等键或直接依赖唯一索引 + SET NX,重复请求返回相同结果

注意:

  • 前端防抖可以被绕过(抓包重放),不能作为唯一保障
  • 限流阈值要区分『取消点赞』和『点赞』两个方向

最终答案:

三层防护:前端加防抖/节流,1 秒内的连续点击只发一次请求;后端对同一用户同一文章做限流(1 秒内只允许一次点赞/取消);最关键的是幂等设计——用唯一索引或 SET NX 让重复请求返回同一个结果而不是重复计数。推荐前端防抖 + 后端幂等兜底:前端防抖可以被绕过,幂等才是最终保证。


思考题

  1. 如果 Redis 内存不足,如何优化点赞数据的存储?

  2. 如何实现”点赞用户列表”功能?显示点赞过某篇文章的所有用户。

  3. 如果平台增长到千万级用户,如何设计计数系统的架构?

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

发现内容有问题?

告诉我们哪里需要改进。