合并写入


写放大问题

系统运行一段时间后,我发现了一个新问题。

监控数据:

Redis 状态:
- QPS:约 8000
- 其中 INCR/DECR:约 6000 次/秒
- 其中 SADD/SREM:约 2000 次/秒

数据库状态:
- QPS:约 1500
- 其中同步写入:约 500 次/秒
- 其中查询:约 1000 次/秒

问题:每次点赞都要同步写入数据库!

每次点赞的流程:
1. 更新 Redis(INCR)
2. 同步写入数据库(INSERT)
3. 更新数据库计数(UPDATE)

影响:
- 数据库压力大
- 响应时间长
- 吞吐量受限

能否减少数据库写入次数?

我想到了合并写入。


合并写入原理

核心思想:

  • 先更新 Redis(立即返回)
  • 将写操作放入队列
  • 定时批量写入数据库
  • 减少数据库写入次数

示意图:

原来:
用户点赞 → 更新 Redis → 写入数据库 → 返回
          ↑______________|
          同步操作,耗时长

合并写入:
用户点赞 → 更新 Redis → 返回(快速)
          ↓
      写入队列
          ↓
      定时批量写入数据库(异步)

优势:

  • 响应时间短(不等待数据库)
  • 吞吐量高(批量写入)
  • 数据库压力小

劣势:

  • 数据可能延迟
  • 实现复杂度高

实现方案

方案 1:内存队列 + 定时写入

核心思路:写操作先进内存队列,后台线程按固定间隔把队列里的增量批量刷进数据库。

import queue
import threading
import time
from collections import defaultdict


class MergeWriter:
    """内存队列 + 定时批量写入"""

    def __init__(self, db, redis_client, flush_interval=1.0, max_batch=500):
        self.db = db
        self.redis = redis_client
        self.flush_interval = flush_interval
        self.max_batch = max_batch
        self.queue = queue.Queue()
        self._stop = threading.Event()
        self._thread = None

    def start(self):
        self._thread = threading.Thread(target=self._run, daemon=True)
        self._thread.start()

    def stop(self):
        self._stop.set()
        if self._thread:
            self._thread.join(timeout=5)

    def enqueue(self, article_id, delta):
        """点赞接口调用:只入队,不等数据库"""
        self.queue.put((article_id, delta))

    def _run(self):
        """后台线程:定时把队列排空并批量写库"""
        while not self._stop.is_set():
            self.flush()
            # 等待下一次刷新;stop 时立刻唤醒
            self._stop.wait(self.flush_interval)
        # 退出前把剩余数据刷完
        self.flush()

    def flush(self):
        """把当前队列里的增量合并后写库"""
        batch = []
        while len(batch) < self.max_batch:
            try:
                batch.append(self.queue.get_nowait())
            except queue.Empty:
                break
        if not batch:
            return 0

        # 同一篇文章的多次增量合并成一条,减少写放大
        deltas = defaultdict(int)
        for article_id, delta in batch:
            deltas[article_id] += delta

        self.db.batch_update_counts(deltas)
        return len(deltas)

写路径变成了什么样:

用户点赞 → Redis INCR(立即返回,0.5ms)
         → 队列.put((article_id, +1))(内存操作,微秒级)
         → 返回

后台线程(每 1 秒):
    取出队列里的 500 条增量
    合并成 {article_id: delta}      ← 关键:写放大在这里被削掉
    一次批量 UPDATE 写进数据库

为什么”合并”是这一章的重点?

没有合并(每条一次写):
    文章 123 被赞 100 次 → 100 条 UPDATE
    数据库写放大 100 倍

合并后:
    文章 123 被赞 100 次 → 1 条 UPDATE,delta = +100
    数据库写放大降到 1 倍

批量写库的实现(注意用 CASE WHEN):

def batch_update_counts(self, deltas):
    """把 {article_id: delta} 批量写入 articles.like_count"""
    if not deltas:
        return

    ids = list(deltas.keys())
    cases = " ".join(
        f"WHEN {int(aid)} THEN like_count + {int(delta)}" for aid, delta in deltas.items()
    )
    sql = (
        f"UPDATE articles SET like_count = like_count + CASE id {cases} END "
        f"WHERE id IN ({','.join(str(int(i)) for i in ids)})"
    )
    self.db.execute(sql)

为什么用 CASE WHEN 而不是循环 UPDATE?

循环 UPDATE:100 条语句 → 100 次网络往返 → 100 次锁获取
CASE WHEN:  1 条语句     → 1 次网络往返     → 1 次批量加锁

同时保证计数自增仍然在数据库端完成(like_count + delta),不会退化成读改写。

这个方案的三个问题:

1. 进程崩溃会丢数据。

内存队列里的数据没有持久化,进程被 kill 时队列里的一切都没了。

应对:定期把队列长度作为指标暴露出来
     队列堆积到阈值时告警
     关键业务不能只靠内存队列

2. 多实例会重复写同一篇文章。

三个应用实例各自有一个队列,各自写库。合并是在实例内部做的,跨实例没有合并。

应对:队列放在 Redis 里(方案 2),由一个消费者组统一消费

3. 刷新间隔是固定值,无法自适应。

流量低的时候每 1 秒刷一次很浪费,流量高的时候又可能刷不过来。

点赞接口

有了合并写入,点赞接口的写路径变成”更新 Redis + 入队”。

class LikeService:
    """点赞服务:Redis 计数 + 合并写入队列"""

    def __init__(self, redis_client, merge_writer):
        self.redis = redis_client
        self.writer = merge_writer

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

    def like(self, article_id, user_id):
        """点赞:Redis 立刻加一,写库异步合并"""
        # 1. Redis INCR:原子、立即可见,这是读路径看到的数字
        new_count = int(self.redis.incr(self._counter_key(article_id)))

        # 2. 记录点赞关系(保证"谁赞了"不会因为合并而丢失)
        self.redis.sadd(f"article:{article_id}:liked_users", user_id)

        # 3. 入队:只带增量,不带绝对值
        self.writer.enqueue(article_id, 1)

        return {"liked": True, "like_count": new_count, "synced": False}

    def unlike(self, article_id, user_id):
        """取消点赞:增量传 -1"""
        new_count = int(self.redis.decr(self._counter_key(article_id)))
        self.redis.srem(f"article:{article_id}:liked_users", user_id)
        self.writer.enqueue(article_id, -1)
        return {"liked": False, "like_count": new_count, "synced": False}

为什么队列里传”增量”而不是”绝对值”?

传绝对值:
    点赞时读出当前 count=100,写库时写 100
    但到真正刷库时 Redis 已经是 150 了 → 写库把 150 覆盖成 100 ❌

传增量:
    点赞时入队 (+1),取消时入队 (-1)
    刷库时累加 → 100 + 50 - 1 = 149 ✅

增量是无状态的、可合并的、可重放的。绝对值是快照,天然会互相覆盖。

点赞记录和计数为什么分开处理?

计数可以合并(100 次点赞 = 1 次 +100),但点赞记录不能合并——每一条 article_likes 记录代表一次独立的行为,合并就丢信息了。

计数:可合并 → 进合并队列
记录:不可合并 → 单独写,或者用 Redis Stream 承载

这也是方案 2 用 Redis Stream 的原因之一。

响应里的 synced 字段:

synced: false 表示”这个数字还没落库”。前端不需要关心它,但排查问题时很有用:用户投诉”数字回滚了”,先看是不是落库延迟导致的。

方案 2:Redis Stream

内存队列最大的问题是进程崩溃会丢数据。Redis Stream 把队列搬到 Redis,天然持久化(AOF),还能支持多个消费者组。

import json


class StreamMergeWriter:
    """基于 Redis Stream 的合并写入"""

    STREAM_KEY = "like:merge:stream"
    GROUP = "like-writers"

    def __init__(self, redis_client, db, batch_size=500, block_ms=2000):
        self.redis = redis_client
        self.db = db
        self.batch_size = batch_size
        self.block_ms = block_ms

    def enqueue(self, article_id, delta):
        """写路径:XADD 进 Stream"""
        self.redis.xadd(
            self.STREAM_KEY,
            {"article_id": str(article_id), "delta": str(delta)},
            maxlen=100000,      # 近似裁剪,防止 Stream 无限增长
            approximate=True,
        )

    def ensure_group(self):
        """创建消费者组(只在第一次启动时创建)"""
        try:
            self.redis.xgroup_create(self.STREAM_KEY, self.GROUP, id="0", mkstream=True)
        except ResponseError:
            pass    # 组已存在

    def consume(self):
        """消费者循环:批量读取 → 合并 → 写库 → ACK"""
        self.ensure_group()
        while True:
            # 读一批消息,阻塞等待最多 block_ms
            messages = self.redis.xreadgroup(
                self.GROUP, "writers",
                {self.STREAM_KEY: ">"},
                count=self.batch_size,
                block=self.block_ms,
            )
            if not messages:
                continue

            deltas = defaultdict(int)
            ack_ids = []
            for _stream, entries in messages:
                for entry_id, fields in entries:
                    deltas[int(fields[b"article_id"])] += int(fields[b"delta"])
                    ack_ids.append(entry_id)

            try:
                self.db.batch_update_counts(deltas)
            except Exception:
                # 写库失败:不 ACK,让消息留在 Pending 里等待重试
                continue

            # 写库成功才 ACK,消息才从 Stream 移除
            if ack_ids:
                self.redis.xack(self.STREAM_KEY, self.GROUP, *ack_ids)

Stream 方案相比内存队列的改进:

维度内存队列Redis Stream
持久化无,进程挂了就丢有,AOF/RDB 兜底
多消费者不支持支持消费者组,多实例共用一个队列
消息确认无有 ACK 机制,失败不丢
积压可见性只能看队列长度XLEN + Pending 列表可观测
延迟最低(内存操作)多一次网络往返(约 1ms)

“写库成功才 ACK”是可靠性的关键。

写库失败 → 不 ACK → 消息留在 Pending Entry List
                  → 消费者重启后可以 XAUTOCLAIM 重新领取

这比内存队列”失败了就没了”要可靠得多。运维上要监控 Pending 列表的长度,它是消息堆积的直接信号。

Stream 的裁剪要小心。

maxlen=100000 是近似裁剪,Redis 会保留略多于 10 万条。但如果写库速度跟不上生产速度,裁剪会把还没消费的消息直接丢掉,造成计数丢失。

裁剪上限必须满足:生产速率 × 最大可容忍中断时间 × 安全系数

生产速率 5000 条/秒,最长中断 10 分钟 = 300 万条,那么 maxlen 至少要大于这个量级。

Stream 的性能代价:

每条消息都要序列化写入 Stream,内存开销比内存队列大很多。计数器这种高频写场景,Stream 的写放大是实打实的成本。

方案 3:优化的合并策略

前两个方案都还有改进空间。优化可以从三个维度入手:合并窗口更聪明、刷新间隔自适应、批量写库更高效。

class AdaptiveMergeWriter:
    """优化后的合并写入:自适应刷新 + 分级合并 + 直写热数据"""

    def __init__(self, redis_client, db,
                 min_interval=0.2, max_interval=5.0,
                 hot_threshold=100,          # 增量超过阈值直接写
                 batch_size=1000):
        self.redis = redis_client
        self.db = db
        self.min_interval = min_interval
        self.max_interval = max_interval
        self.hot_threshold = hot_threshold
        self.batch_size = batch_size
        self.queue = queue.Queue()
        self._stop = threading.Event()
        self._thread = None

    def start(self):
        self._thread = threading.Thread(target=self._run, daemon=True)
        self._thread.start()

    def enqueue(self, article_id, delta):
        self.queue.put((article_id, delta, time.monotonic()))

    def _run(self):
        while not self._stop.is_set():
            interval = self._next_interval()
            self._stop.wait(interval)
            self.flush()
        self.flush()

    def _next_interval(self):
        """根据积压量自适应决定下次刷新间隔"""
        size = self.queue.qsize()
        if size == 0:
            return self.max_interval
        if size < self.batch_size // 10:
            return self.max_interval        # 积压少:慢一点,省资源
        if size > self.batch_size:
            return self.min_interval        # 积压多:快一点,别让延迟失控
        return 1.0                        # 中间状态:固定 1 秒

    def flush(self):
        """分级合并:热数据直写,冷数据批量合并"""
        batch = []
        hot = defaultdict(int)
        deadline = time.monotonic() + self.max_interval

        while len(batch) < self.batch_size:
            try:
                article_id, delta, ts = self.queue.get_nowait()
            except queue.Empty:
                break
            batch.append((article_id, delta))

        if not batch:
            return

        # 同一篇文章的增量合并
        deltas = defaultdict(int)
        for article_id, delta in batch:
            deltas[article_id] += delta

        # 热度判断:增量特别大的文章直接写,避免它长期等在队列里
        cold = {}
        for article_id, delta in deltas.items():
            if abs(delta) >= self.hot_threshold:
                hot[article_id] = delta
            else:
                cold[article_id] = delta

        if cold:
            self.db.batch_update_counts(cold)      # 批量合并写
        if hot:
            for article_id, delta in hot.items():
                self.db.update_count(article_id, delta)   # 热门文章直写

优化点一:自适应刷新间隔。

队列空       → 5 秒刷一次(几乎不占资源)
队列积压多   → 0.2 秒刷一次(快速消化)
中间状态     → 1 秒刷一次

固定间隔做不到这一点:固定 1 秒在低峰时是浪费,在高峰时可能积压几千条。

优化点二:分级合并(热数据直写)。

增量 < 100  → 进批量合并队列,等下一次 flush
增量 >= 100 → 直接单条写库

为什么热门文章要直写?因为它的增量天然就大,等着合并反而会让它的数字更滞后;而单条写对它来说成本也不高。

优化点三:批量大小可调。

队列积压多 → 批量调大(一次写 5000 条),减少往返次数
队列积压少 → 批量调小,避免频繁唤醒数据库

优化点四:带时间戳入队,支持更精细的窗口控制。

入队时记录 time.monotonic(),可以做到”只合并最近 N 秒内的增量”,更早的增量优先写出,缩短延迟尾部。

三种方案对比:

维度内存队列Redis Stream优化合并策略
数据可靠性弱(进程挂就丢)强(AOF + ACK)中(取决于队列实现)
延迟最低1~2ms可控(自适应)
写库次数少少最少
复杂度低中高
适用允许少量丢失不允许丢追求吞吐和延迟平衡

性能对比

测试代码

测试要验证合并写入的三个核心行为:增量正确累加、重复刷写不重复计数、失败不丢数据。

import unittest
from unittest.mock import MagicMock, patch


class MergeWriterTestCase(unittest.TestCase):
    """合并写入的单元测试"""

    def setUp(self):
        self.db = MagicMock()
        self.redis = MagicMock()
        self.writer = MergeWriter(self.db, self.redis, flush_interval=0.01)
        self.writer.db.batch_update_counts = MagicMock()

    def test_merges_same_article_into_one_delta(self):
        """同一篇文章的多次增量合并成一条"""
        self.writer.enqueue(123, 1)
        self.writer.enqueue(123, 1)
        self.writer.enqueue(123, 1)

        self.writer.flush()

        # 只调用一次批量写,且 delta 是 +3
        self.writer.db.batch_update_counts.assert_called_once()
        deltas = self.writer.db.batch_update_counts.call_args[0][0]
        self.assertEqual(deltas[123], 3)

    def test_merges_different_articles_separately(self):
        """不同文章各自合并"""
        self.writer.enqueue(123, 1)
        self.writer.enqueue(456, 1)
        self.writer.enqueue(456, 1)

        self.writer.flush()

        deltas = self.writer.db.batch_update_counts.call_args[0][0]
        self.assertEqual(deltas[123], 1)
        self.assertEqual(deltas[456], 2)

    def test_unlike_delta_is_negative(self):
        """取消点赞传的是负增量"""
        self.writer.enqueue(123, 1)
        self.writer.enqueue(123, -1)

        self.writer.flush()

        deltas = self.writer.db.batch_update_counts.call_args[0][0]
        self.assertEqual(deltas[123], 0)    # 一加一减,净增量为 0

    def test_flush_is_idempotent_on_empty_queue(self):
        """队列为空时刷写不报错、不写库"""
        self.writer.flush()

        self.writer.db.batch_update_counts.assert_not_called()

    def test_drain_queue_after_flush(self):
        """刷写后队列被排空,重复刷写不会重复计数"""
        self.writer.enqueue(123, 5)

        self.writer.flush()
        self.writer.flush()          # 再刷一次,队列已经空了

        self.writer.db.batch_update_counts.assert_called_once()
        deltas = self.writer.db.batch_update_counts.call_args[0][0]
        self.assertEqual(deltas[123], 5)


class LikeServiceTestCase(unittest.TestCase):
    """点赞接口的单元测试"""

    def setUp(self):
        self.redis = MagicMock()
        self.writer = MagicMock()
        self.service = LikeService(self.redis, self.writer)
        self.redis.incr.return_value = 101
        self.redis.decr.return_value = 99

    def test_like_increments_redis_and_enqueues(self):
        """点赞:Redis +1,同时入队一条 +1 增量"""
        result = self.service.like(123, 1001)

        self.redis.incr.assert_called_once_with("article:123:like_count")
        self.writer.enqueue.assert_called_once_with(123, 1)
        self.assertEqual(result["like_count"], 101)

    def test_unlike_decrements_redis_and_enqueues(self):
        """取消点赞:Redis -1,入队一条 -1 增量"""
        result = self.service.unlike(123, 1001)

        self.redis.decr.assert_called_once_with("article:123:like_count")
        self.writer.enqueue.assert_called_once_with(123, -1)
        self.assertEqual(result["like_count"], 99)

    def test_like_records_user_in_liked_set(self):
        """点赞关系要写进集合,合并不会丢记录"""
        self.service.like(123, 1001)

        self.redis.sadd.assert_called_once_with(
            "article:123:liked_users", 1001
        )


if __name__ == "__main__":
    unittest.main()

测试和真实行为的一致性检查表:

行为对应断言失败意味着
同文章增量合并test_merges_same_article_into_one_delta写放大没被削掉,数据库压力照旧
加减净增量为 0test_unlike_delta_is_negative计数会被重复累加
刷写后排空队列test_drain_queue_after_flush同一批数据会被写进数据库两次
点赞关系入集合test_like_records_user_in_liked_set“谁赞了”会丢失

运行:

python -m unittest test_merge_write.py -v

实际效果

监控数据

合并写入上线后:

Redis 状态:
- QPS:约 8000(不变)
- 响应时间:平均 0.5ms(更快)

数据库状态:
- QPS:从 1500 降到 150(降低 90%)
- 其中写入:从 500 降到 50(批量写入)
- 响应时间:平均 10ms

系统吞吐量:
- 从 200 req/s 提升到 2000 req/s
- 提升 10 倍!

数据一致性

延迟分析:
- 最大延迟:1 秒(刷新间隔)
- 平均延迟:0.5 秒
- 对用户影响:几乎无感知

数据准确性:
- 最终一致性
- 定期对账验证
- 不一致率 < 0.1%

课后练习

练习 1

合并写入时,如何处理”用户点赞后立即取消”的情况?

合并写入去重优化

解题思路:

这道题问的是合并写入把多次操作攒成一次落库时,『点赞后马上取消』会在净增量上被抵消,但业务上这是一次真实的点赞-取消对,语义仍然要正确。

详细步骤:

方案:操作去重

问题本质:

  • 点赞后立即取消,净计数变化为 0
  • 但业务上这是一次真实的点赞-取消对,点赞记录表可能已写入又删除
  • 合并粒度选错时,不同用户的操作会被错误抵消

合并规则:

  1. 合并键 = (user_id, article_id),保证同一次点赞-取消落在同一条待写记录上
  2. 同一合并窗口内,+1 与 -1 相互抵消,净增量为 0 时不落库
  3. 需要保留行为痕迹时,单独写操作流水表(用于埋点与审计)

需要注意:

  • 合并窗口要短(通常秒级),窗口越长抵消掉的真实行为越多
  • 抵消判断必须用整型 delta,不能用布尔标记,否则连点三次会算错

最终答案:

合并写入时按净增量合并:合并键必须是『用户 + 文章』维度,同一窗口内的 +1 与 -1 相互抵消,净增量为 0 就不落库;如果业务需要保留这两次行为(如埋点、审计),则另外写一条操作流水。关键在于合并粒度必须是用户 + 文章维度,否则不同用户的变化会被错误地互相抵消。

练习 2

合并写入队列满时如何处理?

合并写入流控降级

解题思路:

这道题问的是队列写满就意味着要么丢数据要么拖垮写入方,所以解法必须分清『能等』和『不能等』两类流量,并给出明确的降级动作。

详细步骤:

方案:限流 + 降级

队列满的两种含义:

  • 瞬时突发:消费速度跟不上,短时阻塞即可恢复
  • 持续积压:下游(数据库)已经扛不住,必须限流

处理步骤:

  1. 设置队列容量上限,写入前判断是否接近上限
  2. 接近上限时按任务优先级丢弃:埋点/统计可丢,计数不可丢
  3. 计数任务改为:同步写库、缩小合并窗口,或落到本地磁盘溢出队列
  4. 触发告警,提示扩容消费者或降低写入量

注意:

  • 阻塞等待要有超时上限,避免拖垮上游请求线程
  • 降级必须可观测:降级次数与丢弃量要进监控

最终答案:

队列满时用『限流 + 降级』两级处理:先按优先级丢弃可丢弃的任务(埋点、统计类增量),保证计数类任务不被丢;对必须保留的任务则短暂阻塞等待或落到本地磁盘做溢出存储,并触发告警。核心原则是让核心计数链路尽量不丢,非核心数据可以容忍最终一致甚至丢弃。

练习 3

如何保证合并写入的数据不丢失?

可靠性持久化容灾

解题思路:

这道题问的是『从请求返回到真正落库』这条链路上有哪些丢数据的环节,所以要沿着链路逐段排查内存队列这一环。

详细步骤:

方案:持久化队列

丢数据的环节:

  • 进程崩溃时内存队列里的任务全部丢失
  • 消费成功但 ack 之前宕机 → 重复消费
  • 落库失败后任务被直接丢弃

解决方案:

  1. 队列持久化:Redis Stream / Kafka 等,消息落盘而非只存在内存
  2. 手动 ack:落库成功后才 ack;失败则保留消息等待重投
  3. 重试与死信:超过重试次数的消息进死信队列,人工介入而不是丢弃
  4. 幂等写入:落库用唯一键(如 user_id + article_id + batch_id)去重,重复投递不会写重

最终答案:

关键在于合并队列不能只放在内存里。用持久化队列(Redis Stream / Kafka)承载待写任务,消息被消费并成功落库后才 ack;进程异常退出时未 ack 的消息可被重新投递,落库与 ack 之间用幂等写入(唯一键 + 去重)兜住重复消费。这样即使消费者宕机或重启,待写数据也不会丢。

练习 4

合并写入时如何监控”延迟”?

监控延迟性能指标

解题思路:

这道题问的是『从用户点击到数字真的更新』的端到端延迟,要先把它拆成入队等待、合并等待、消费处理三段,再分别埋点。

详细步骤:

方案:记录时间戳

延迟分解:

  1. 入队等待:请求进入队列到被消费者取走,反映队列是否积压
  2. 合并等待:一条记录被放进合并窗口、等待窗口结束才落库
  3. 消费处理:取出到完成落库的时间,反映下游写入性能

采集方式:

  • 消息里带 enqueue_ts,落库时打 commit_ts,两者相减
  • 按『文章 ID』或『用户 ID』分桶统计,避免长尾被平均值掩盖

告警建议:

  • 延迟 P99 超过阈值
  • 队列深度持续增长(消费能力不足)

最终答案:

用时间戳做端到端延迟度量:请求进入时打 enqueue_ts,消费落库时打 commit_ts,延迟 = commit_ts - enqueue_ts。再结合队列维度分别监控『入队等待时长』、『消费处理时长』和『队列积压量』,并对延迟 P99 与积压量设置告警。采样时按文章或用户分桶统计,避免长尾被平均值掩盖。

练习 5

合并写入时,如何处理”数据库故障”?

容错故障处理可靠性

解题思路:

这道题问的是下游数据库不可用时合并写入链路怎么活下来,核心是『不能丢也不能无限重试』这两个约束。

详细步骤:

方案:重试 + 死信队列

故障处理步骤:

  1. 落库失败 → 不 ack,消息保留在队列中
  2. 按指数退避重试(1s、2s、4s…),避免雪崩式重试打死数据库
  3. 超过最大重试次数 → 消息转入死信队列
  4. 触发告警,标注受影响的文章/用户
  5. 数据库恢复后,由补偿任务按顺序重放死信队列,并做幂等校验

注意:

  • 重试必须带退避,不要立即重试
  • 死信队列要可人工查看和手动重放
  • 故障期间可以降级为『只读展示缓存值』,不提供写服务

最终答案:

用『重试 + 死信队列』兜底:数据库不可用时消费者不确认消息,按指数退避重试;超过重试上限后把消息转入死信队列并告警,数据库恢复后再由专门的补偿任务重放死信。整个过程依赖持久化队列,保证故障期间任务不丢。


思考题

  1. 合并写入的”刷新间隔”如何设置?

  2. 如果用户点赞后立即查询,可能查不到数据,如何处理?

  3. 合并写入和”延迟双删”如何配合使用?

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

发现内容有问题?

告诉我们哪里需要改进。