你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,和一次 RocksDB 磁盘风暴复盘

2026-11-18 14 0

你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,与一次 RocksDB 磁盘风暴复盘

你有没有遇到过这种场面:业务代码一行没改,写入延迟从 1ms 慢慢爬到 200ms,机器 CPU 看着也不高,内存还有一半空着,但磁盘的 iowait 却一路飘红。运维拉来一张图,指着那条忽高忽低的写延迟曲线问:兄弟,你这写入放大是不是又发作了?

如果你用 LevelDB / RocksDB / Cassandra / TiKV / CockroachDB,那大概率不是玄学,是 LSM-Tree 的"性格"发作了。它跟老派 B+Tree 引擎(InnoDB、bbolt、LMDB)根本不是一路人,两种设计哲学的差别,比"甜党"和"咸党"的差别还大。

这篇咱们把这事掰开揉碎讲清楚:为什么 LSM 写这么快、代价是什么、以及它到底会在什么时候原地爆炸。


一、分歧的起点:一个想原地改,一个只会往前写

B+Tree 的思路非常古典:数据存在有序的页里,你更新一行,就找到那一页,原地覆盖它。这带来两个天然优点:

  • 读放大极低:一次树查找就能定位到数据页,磁盘 IO 次数约等于树高(通常 3~4 次)。
  • 空间紧凑:同样的数据量,占用空间小,页利用率高。

代价也相当直接:随机写。哪怕你只改一个字节,也可能要读出 16KB 的页、改完、再整页刷回磁盘。页被缓存命中时无所谓,没命中时就是一次真实的随机 IO。

LSM-Tree 换了个思路:我不改,我往后写。

写入路径:
  WAL 追加落盘  →  写入 MemTable(内存中的有序结构)
                      ↓ MemTable 满了 / 达到阈值
                 刷成 SSTable(不可变的磁盘文件)
                      ↓ SSTable 越积越多
                 Compaction 合并成更大的文件

所有写入都变成 顺序追加。顺序写对磁盘是最友好的形态——SSD 的并行通道能吃饱,机械盘也能靠顺磁头把寻道成本降到最低。于是"随机写 5ms"变成了"顺序写 0.3ms",这一下就是十倍以上的差距。

这就是 LSM 的全部魅力:用空间和延迟的复杂度,去换写入吞吐的确定性。


二、三把刀:写入放大、读放大、空间放大

天下没有免费的午餐。LSM 的快,是"预支"出来的,代价有三个,都得算在账上。

1. 写入放大(Write Amplification)

你写 1KB 的用户数据,实际落到磁盘上的可能是 10KB、20KB。因为:数据先写 WAL,再写 memtable,刷成 SSTable 后,还要参与多轮 compaction 被反复读写。一个字节从内存走到磁盘,被盘了几道。

理论放大 ≈ 层数 × (每层数据总量 / 每层大小比)

这就是为什么 compaction 的 IO 占用会突然吃掉你整块盘:真正的写入大头不是你的业务数据,而是后台合并。

2. 读放大(Read Amplification)

要查一个 key,你可能要依次查 memtable、L0 的多个文件、L1、L2……每层都可能命中,也可能不命中。这就是为什么 RocksDB 默认给每个 SSTable 配布隆过滤器(Bloom Filter)——它负责在不读盘的前提下告诉你"这个文件里肯定没有你要的 key",直接跳过磁盘 IO。

没有布隆过滤器的 LSM,读性能会塌给你看。这也是很多人在自建存储时容易漏掉的一环。

3. 空间放大(Space Amplification)

老数据还没被 compaction 清理掉,新数据又写进来了,同一份数据在多层里各存一份。磁盘水位莫名其妙地涨上去,然后你就接到了那个经典电话:"兄弟,磁盘满了,线上写不进去了。"


三、复盘现场:一次删除风暴引发的磁盘风暴

想象一个典型场景:业务要做"逻辑删除",于是每删一条记录就写一个 DEL 墓碑(tombstone)。听起来很标准,直到某天运营跑了个批量清理任务,一晚上删了 2000 万行。

灾难是这样发生的:

  1. 大量墓碑散落在 L0 的各个 SSTable 里;
  2. Compaction 把它们一层层往下推,每推一层就要重写一次;
  3. 墓碑只有在"被推到最底层、且下方确实存在被删除的旧版本数据"时才能被丢弃;
  4. 只要下面还留着数据,墓碑就必须留着——它带着一整份旧数据继续往下走,像是拖着尸体前行的队伍。

结果是:磁盘写入量飙到平时的十几倍,iowait 打满,compaction 线程抢不到 IO 配额,写入延迟从毫秒级被拖到几百毫秒,而业务侧看到的现象是"接口偶尔卡一下"。

排查时最容易被误导的地方在于:CPU 不高、内存没满、机器也没重启,于是大家开始怀疑网络、怀疑下游、怀疑 GC。真正的原因藏在 compaction_pending 这个指标里:待合并的文件在堆积,而后台线程已经拼尽全力了。

关键的几条止损动作

  • 批量范围删除代替逐条删除:写一个 range tombstone 覆盖整个区间,而不是成千上万个单点墓碑;
  • 控制单批删除量:大批量删要分批、限速,让 compaction 有机会跟上;
  • 观察 compaction 积压而非只看写延迟:积压是先行指标,写延迟是滞后指标;
  • 给磁盘留足水位线:别等 100% 满,80% 就该触发降级或扩容;
  • 控制 memtable 大小和 flush 节奏:flush 太频繁会产生大量小文件,太稀疏则让 L0 堆积。

四、调参不是玄学,是一张权衡表

RocksDB 的参数看着吓人,其实都围绕同一个核心问题转:你在写延迟、读延迟、空间、后台 IO 之间,愿意拿哪一个去换哪一个?

-- 写多读少、批量导入型负载
write_buffer_size = 64MB            # 更大的 memtable => 更少 flush => 更少 L0 文件
max_background_jobs = 8              # 多给 compaction 一点线程,否则它永远追不上
min_write_buffer_number_to_merge = 4 # 攒够几个 memtable 再 flush,减少小文件

-- 读多写少、在线服务
bloom_filter = bloom:10             # 每个 key 10 bit,假阳性率约 1%
block_cache = 256MB                 # 给热数据准备缓存
max_open_files = -1                 # 别频繁 open/close 文件

-- 磁盘吃紧
max_bytes_for_level_base = 512MB    # 压小 L1,限制单层膨胀
level_compaction_dynamic = true

几条通用建议:

第一,永远给 compaction 留够 IO 带宽。Compaction 是后台任务,抢不到 IO 的时候它就不动,而它不动,磁盘就会越来越满。这是一条正反馈的死亡螺旋。

第二,监控要看三个核心指标:compaction_pending(积压)、sstables_per_level(各层文件数)、bytes_written(真实写放大)。只看 QPS 和 P99,你会在事故现场才开始怀疑人生。

第三,不要用 RocksDB 当关系库使。它的随机点查性能比 B+Tree 引擎差,事务能力和关系语义也弱。用它存 KV、时间序列、时序指标、写多读少的海量数据,才是它的主场。


五、那到底该选谁?

没有银弹,但选型其实相当清晰:

  • B+Tree(InnoDB / bbolt / LMDB):读多写少、强事务、点查为主、要求稳定可预测的延迟。它是"会计"——一笔一笔记得清清楚楚。
  • LSM(RocksDB / LevelDB / Cassandra 的 SSTable):写多读少、日志/时序/指标类数据、海量写入、顺序扫描。它是"仓库"——东西往里扔,压缩打包,查询时再翻。
  • 另外还有第三条路:比如 WAL + Checkpoint 的整块复制型引擎(LMDB 属于此类)、或者直接上 LSM 的改良变体(TiKV、CockroachDB 都在各自改造它)。

顺带一提,MongoDB 的 WiredTiger、etcd 早期的 bbolt、SQLite 的 B+Tree,选择的都是另一条路。这说明一件事:存储引擎的选型,从来不是"谁更先进",而是"谁更匹配你的写入模式和延迟容忍度"。


六、写在最后

LSM-Tree 教会我们的事,其实是所有工程里都成立的那一条:

你获得的每一分性能,都是从别处换来的。LSM 用空间和读延迟换写吞吐,B+Tree 用写延迟换读性能,Redis 用持久化能力换内存速度。没有免费的架构,只有明码标价的交易。

所以,下次再看到"写入很慢",别急着甩锅给代码。先问三个问题:磁盘水位多少?compaction 积压多少?真实写放大是多少?

问完这三个问题,答案通常已经在日志里躺着了,就等你翻开。

而如果你看到的是另一幕——写入其实很快,延迟却毫无规律地随机抖动——那多半是另一个故事了:所有副本在同一时刻醒来,定时任务惊群。那个话题,值得单独开一篇。

相关文章

42 KB 的请求,打爆 126 MB 的内存:gzip 解压炸弹,你的接口正裸奔
缓存没坏,你的服务却挂了:穿透、击穿、雪崩,以及那份永远对不上的数据
一个连接扛住十倍并发,然后被自己的 64KB 掐死了:HTTP/2 流控窗口的真相
你的 Node 服务只有一个线程,却扛住了十万并发:事件循环的真相,和它翻车的三种姿势
你的搜索为什么慢得像在刨坟:Elasticsearch 倒排索引的一次翻车现场
你加了一个字段,生产环境炸了:论 API 兼容性的真正战场

发布评论