# 第 36 章：依赖变慢的时候

> 存储分成 20 片，其中一片的磁盘坏了，每次读写从 5 毫秒变成 500 毫秒。什么都没挂，为什么几乎所有人打开 App 都在转圈？

深入理解 IM 系统 · https://im.liko.page/zh/failing-dependencies/

晚上 8 点，高峰。v3 存会话记录的存储分成 20 片，按用户分。其中一片的磁盘出了毛病：每次读写从 5 毫秒变成 500 毫秒。它没有挂，监控上它还“活着”。

几分钟后，客服收到一堆投诉：打开 App 一直转圈，会话列表不动，未读数不对。可坏的只是 20 片里的一片，照理只该影响二十分之一的人。

这一章的问题：**一个依赖变慢时，怎么让慢只落在真正用到它的那部分上，而不是扩散到所有人？**

## 1. 发消息不受影响

先说好消息。第 29 章以后，确认（ACK）只等消息日志，不等存储。如果确认还在等存储（v2 的做法），高峰每秒 13,900 条、每条等 500 毫秒，同时会有 6,950 条卡在半路。现在一条也不卡。

还在等存储的是两样：

- **同步**：每次打开 App，同步服务要读这个人变了的会话记录（第 11 章）。v3 高峰每秒约 6,944 次。
- **会话记录**（每人每个会话一行，记着最新 seq、读到哪）：日志后面的一个消费者，给每条消息的每个收件人改一条（第 11、29 章），每秒约 92,667 次。

## 2. 慢，就是占着地方

有一条简单的关系，叫**利特尔法则**：同时在等的请求数 = 每秒来的数 × 每个等多久。

读坏分片的同步，是 6,944 次的二十分之一，每秒 347 次。分片正常时，同时只有不到 2 个在等；每个等 500 毫秒，就是 174 个。

可实际比这糟。平时这一片每秒写 2 万行、每行 5 毫秒，按同一条法则，它同时在做的是 2 万 × 0.005 = 100 行，这是它一次做得了的上限。磁盘慢了，上限还是 100 行，每行却要 500 毫秒，它每秒只做得完 100 ÷ 0.5 = 200 行，送来的活却有约 9,600 行：落在这一片上的会话记录更新每秒约 4,600 次，每次两行，再加上同步的读。

排在后面的请求等不到回答，只能等到超时。假设存储客户端的超时设成 30 秒，没人为这类调用另设，每个就等满 30 秒，同时在等的就是 347 × 30 ≈ **10,417** 个。

每个在等的请求都占着调用方的东西：一个连接、一块内存、一个名额。

## 3. 一个池子，大家一起等

同步服务为了不被压垮，会限制同时在等存储的请求数。假设整个服务限 2,000 个，平时只用 35 个，余量很大。

可这 2,000 个名额是 20 片共用的。读坏分片的请求每秒进来 347 个，每个占 30 秒，不到 6 秒就把名额全占了。之后每秒只空出约 67 个名额（2,000 个 ÷ 30 秒），其中约 63 个轮到健康分片的用户，可他们每秒要 6,597 个：只够 1%。

模拟里还要更糟：手机等 10 秒没回答就放弃（第 6 节），名额空出来时，先排到的却是队伍最前面、等得最久的请求，它们的手机早就放弃了。坏分片病了约 9 秒以后，健康分片的用户打开 App，100 次里成功不到 1 次。服务端还在认真回答早已没人等的请求，这一分钟的病下来，答了约 29 万次。

坏的是 5% 的数据，转圈的是几乎 100% 的人。Slack 2021 年 1 月 4 日的故障里也是这个样子：网络丢包让 web 层调后端变慢，“使 web 层的系统资源饱和”，Slack 随即不可用（[Slack Engineering](https://slack.engineering/slacks-outage-on-january-4th-2021/)）。

## 4. 按顺序的消费者，被慢的那几条卡住

会话记录的消费者，每个日志分区一个，按顺序往前走：它可以同时写好几条，但它记着的“处理到哪”只能挪过已经写完的那些（第 29 章）。比如 1 到 50 号同时在写，3 号卡住了，4 到 50 号都写完了，“处理到哪”也只能停在 2 号。

假设日志有 100 个分区，每区高峰每秒要改 927 条记录。第 34 章假设一个消费者每秒改得了 10,000 条，也就是同时有 50 条在写。

收件人散在 20 片上，所以每 20 条里就有 1 条在坏分片上，一等就是 30 秒。50 个写的位子很快都被这样的记录占住：平均每条要写约 1.5 秒（30 秒的二十分之一），50 个位子每秒只轮得过约 33 条，是要改的 4%。

结果是每个分区都落后，**所有人**的会话列表、未读数都停住了，不只是坏分片上的人。病一分钟，每区落后约 58 秒。第 34 章里一个刷屏的群卡住一个分区；这里一片坏存储卡住了所有分区。

第 17 章的系统推送也在这个消费者里：改完记录，再调 APNs 或手机厂商的通道。哪家通道卡住，同样会卡住分区。

## 5. 重试让它更糟

每一层都觉得“失败了就再试几次”是好习惯。同步服务对存储重试 3 次，坏分片收到的最多是 4 倍；手机对同步服务也重试 3 次，最多 4 × 4 = 16 倍。Google 的 SRE 书里举的例子是三层各重试 3 次，一次用户操作在数据库上变成 64 次（[Addressing Cascading Failures](https://sre.google/sre-book/addressing-cascading-failures/)）。

一个已经只剩百分之一能力的分片，最不需要的就是更多请求。

## 6. 办法：让慢只落在用到它的地方

**每次调用都有截止时间，比调用方的短。** 手机等 10 秒；同步服务给整个回答 5 秒；其中一次存储调用 1 秒。截止时间跟着请求往下传，下一层先看还剩多少时间，不够就不做（SRE 书叫它 deadline propagation）。1 秒的截止时间下，坏分片上同时等着的从 10,417 个降到 347 个。

**每个依赖、每个分片，各有自己的名额。** 坏分片最多占它自己的 100 个（它同时也只做得了这么多），满了的立刻拒绝，不排队。其他 19 片的名额一个也不少。这叫**隔舱**（bulkhead）：船舱漏了一格，不沉整条船。

**失败多了就熔断，然后降级。** 一段时间里对坏分片的调用大多失败，就先不调它，直接返回失败，隔一阵再放几个试探。同步不必全有或全无：手机本地已经有会话列表，各会话最新的 seq 和最新一条消息在第 29 章的缓存里，照样返回；变了的会话记录标成“稍后再给”。坏分片上那 5% 的人，打开 App 能看到新消息，只是新加的会话、置顶、免打扰这些晚一点。

**慢的活另排一队。** 会话记录的消费者碰到坏分片上的那一条，不等它，把它放进这个分片自己的重试队列（也是一个日志），接着往下走。只靠截止时间还不够：每条最多等 1 秒，消费者也只跟得上 99%，还是一点点落后；熔断以后直接放进队列，才回到全速。系统推送也一样：每个通道一个队列，谁卡了只卡自己。

病一分钟，坏分片的队列里积下约 27.8 万条（每秒 4,633 条 × 60 秒），好了以后用它的空余能力（每秒 1 万条，减去平时的 4,633 条）52 秒补完。其他 95% 的人，会话列表一直是新的。

**重试有预算。** 重试的次数最多占调用的 10%，超出就直接失败。SRE 书的数字：只限制每个请求最多试 3 次，最坏时负载接近 3 倍；加上这一成的预算，一般只到 1.1 倍（[Handling Overload](https://sre.google/sre-book/handling-overload/)）。并且只在一层重试，最好是离失败最近的那一层。

## 7. 代价

- **用户会看到错误。** 快速失败、降级，意味着有人看到“稍后再试”，或者少了一部分数据。这是故意的：5% 的人少一点，好过 100% 的人转圈。
- **每个超时、名额、熔断阈值都是一个会配错的数。** 太紧，平时的毛刺就会触发；太松，等于没有。它们只在坏日子里起作用，所以要在演练里试（第 38 章）。
- **另排的队列也要有人看。** 积了多少、多久没补完，都是要监控的数（第 33 章）。
- **补回来的顺序会乱。** 重试队列里的一条比后面的消息晚写；会话记录只往上涨（第 11 章）：最新 seq 已经是 4,830，重试队列里晚到一条“改成 4,812”，比现在的小，不改，所以晚到的旧值不会盖住新值。

## 8. 其他答案

- **Netflix 的 Hystrix。** 一个 Java 库，把每个依赖包在自己的小线程池（或信号量）里，满了就拒绝，错误率过阈值就熔断。它的文档说，流量大时，一个变慢的后端“能在几秒内让所有服务器上的所有资源饱和”（[Hystrix wiki](https://github.com/Netflix/Hystrix/wiki)）。它现在处于维护状态，不再开发（[README](https://github.com/Netflix/Hystrix)），但隔舱和熔断这两个做法留了下来。
- **只靠超时。** 最简单，能防住“永远等下去”；但名额共用时，一个 1 秒的超时仍然让坏分片占掉 347 个名额，挤占多少，看池子多大。
- **按优先级让路。** 不分依赖，而是给请求分轻重，满了先丢不重要的（第 34 章）。两者常一起用。
- **自适应的并发上限。** 不写死名额，按观察到的延迟自动调小调大。省了配置，多了一套要理解的算法。

## 9. 这一章的决定

**决策卡**

- 问题：一个存储分片从 5 毫秒变慢到 500 毫秒，什么都没挂。等它的请求占满共用的名额，按顺序的消费者被它卡住，重试再把负载翻几倍，20 片里坏一片，几乎所有人的同步和会话列表都停了。
- 选择：每次调用都有截止时间，比调用方的短，并往下传；每个依赖、每个分片各有自己的名额，满了立刻拒绝；失败多了就熔断，同步降级为只给缓存里的部分；消费者把慢的活放进各自的重试队列，接着往下走；重试不超过一成，只在一层。
- 代价：用户会看到错误和不全的数据；超时、名额、阈值都可能配错，只在坏日子里才知道；重试队列要监控；补回来的行晚到。
- 什么时候重新考虑：消息到底送到没有（第 33 章）；来的比扛得住的多（第 34 章）；丢掉一个机房（第 37 章）；这些设置有没有用，靠演练（第 38 章）。
- 其他答案：Hystrix 式的线程池隔离和熔断；只靠超时；按优先级丢弃；自适应并发上限。

一片存储慢了，慢只落在它自己的那 5% 上。可要是整个机房都没了呢？下一章：丢了一个机房。
