合并写入
系统运行一段时间后,我发现了一个新问题。
监控数据:
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 | 写放大没被削掉,数据库压力照旧 |
| 加减净增量为 0 | test_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
- 但业务上这是一次真实的点赞-取消对,点赞记录表可能已写入又删除
- 合并粒度选错时,不同用户的操作会被错误抵消
合并规则:
- 合并键 = (user_id, article_id),保证同一次点赞-取消落在同一条待写记录上
- 同一合并窗口内,+1 与 -1 相互抵消,净增量为 0 时不落库
- 需要保留行为痕迹时,单独写操作流水表(用于埋点与审计)
需要注意:
- 合并窗口要短(通常秒级),窗口越长抵消掉的真实行为越多
- 抵消判断必须用整型 delta,不能用布尔标记,否则连点三次会算错
最终答案:
合并写入时按净增量合并:合并键必须是『用户 + 文章』维度,同一窗口内的 +1 与 -1 相互抵消,净增量为 0 就不落库;如果业务需要保留这两次行为(如埋点、审计),则另外写一条操作流水。关键在于合并粒度必须是用户 + 文章维度,否则不同用户的变化会被错误地互相抵消。
练习 2
合并写入队列满时如何处理?
解题思路:
这道题问的是队列写满就意味着要么丢数据要么拖垮写入方,所以解法必须分清『能等』和『不能等』两类流量,并给出明确的降级动作。
详细步骤:
方案:限流 + 降级
队列满的两种含义:
- 瞬时突发:消费速度跟不上,短时阻塞即可恢复
- 持续积压:下游(数据库)已经扛不住,必须限流
处理步骤:
- 设置队列容量上限,写入前判断是否接近上限
- 接近上限时按任务优先级丢弃:埋点/统计可丢,计数不可丢
- 计数任务改为:同步写库、缩小合并窗口,或落到本地磁盘溢出队列
- 触发告警,提示扩容消费者或降低写入量
注意:
- 阻塞等待要有超时上限,避免拖垮上游请求线程
- 降级必须可观测:降级次数与丢弃量要进监控
最终答案:
队列满时用『限流 + 降级』两级处理:先按优先级丢弃可丢弃的任务(埋点、统计类增量),保证计数类任务不被丢;对必须保留的任务则短暂阻塞等待或落到本地磁盘做溢出存储,并触发告警。核心原则是让核心计数链路尽量不丢,非核心数据可以容忍最终一致甚至丢弃。
练习 3
如何保证合并写入的数据不丢失?
解题思路:
这道题问的是『从请求返回到真正落库』这条链路上有哪些丢数据的环节,所以要沿着链路逐段排查内存队列这一环。
详细步骤:
方案:持久化队列
丢数据的环节:
- 进程崩溃时内存队列里的任务全部丢失
- 消费成功但 ack 之前宕机 → 重复消费
- 落库失败后任务被直接丢弃
解决方案:
- 队列持久化:Redis Stream / Kafka 等,消息落盘而非只存在内存
- 手动 ack:落库成功后才 ack;失败则保留消息等待重投
- 重试与死信:超过重试次数的消息进死信队列,人工介入而不是丢弃
- 幂等写入:落库用唯一键(如 user_id + article_id + batch_id)去重,重复投递不会写重
最终答案:
关键在于合并队列不能只放在内存里。用持久化队列(Redis Stream / Kafka)承载待写任务,消息被消费并成功落库后才 ack;进程异常退出时未 ack 的消息可被重新投递,落库与 ack 之间用幂等写入(唯一键 + 去重)兜住重复消费。这样即使消费者宕机或重启,待写数据也不会丢。
练习 4
合并写入时如何监控”延迟”?
解题思路:
这道题问的是『从用户点击到数字真的更新』的端到端延迟,要先把它拆成入队等待、合并等待、消费处理三段,再分别埋点。
详细步骤:
方案:记录时间戳
延迟分解:
- 入队等待:请求进入队列到被消费者取走,反映队列是否积压
- 合并等待:一条记录被放进合并窗口、等待窗口结束才落库
- 消费处理:取出到完成落库的时间,反映下游写入性能
采集方式:
- 消息里带 enqueue_ts,落库时打 commit_ts,两者相减
- 按『文章 ID』或『用户 ID』分桶统计,避免长尾被平均值掩盖
告警建议:
- 延迟 P99 超过阈值
- 队列深度持续增长(消费能力不足)
最终答案:
用时间戳做端到端延迟度量:请求进入时打 enqueue_ts,消费落库时打 commit_ts,延迟 = commit_ts - enqueue_ts。再结合队列维度分别监控『入队等待时长』、『消费处理时长』和『队列积压量』,并对延迟 P99 与积压量设置告警。采样时按文章或用户分桶统计,避免长尾被平均值掩盖。
练习 5
合并写入时,如何处理”数据库故障”?
解题思路:
这道题问的是下游数据库不可用时合并写入链路怎么活下来,核心是『不能丢也不能无限重试』这两个约束。
详细步骤:
方案:重试 + 死信队列
故障处理步骤:
- 落库失败 → 不 ack,消息保留在队列中
- 按指数退避重试(1s、2s、4s…),避免雪崩式重试打死数据库
- 超过最大重试次数 → 消息转入死信队列
- 触发告警,标注受影响的文章/用户
- 数据库恢复后,由补偿任务按顺序重放死信队列,并做幂等校验
注意:
- 重试必须带退避,不要立即重试
- 死信队列要可人工查看和手动重放
- 故障期间可以降级为『只读展示缓存值』,不提供写服务
最终答案:
用『重试 + 死信队列』兜底:数据库不可用时消费者不确认消息,按指数退避重试;超过重试上限后把消息转入死信队列并告警,数据库恢复后再由专门的补偿任务重放死信。整个过程依赖持久化队列,保证故障期间任务不丢。
-
合并写入的”刷新间隔”如何设置?
-
如果用户点赞后立即查询,可能查不到数据,如何处理?
-
合并写入和”延迟双删”如何配合使用?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
