第三十五夜 · 恢复风暴
第34夜的结尾留了两笔债。一笔是答案的另一半,报告侧敢一把互斥锁都不加地同跑,结构给的那一半当夜讲完,部署给的那一半留到现在。另一笔是 3 个开关,一场风暴。这一夜两笔一起还。
先把场子摆正。这座代码库里,报文进门有 3 种走法,走法决定线程,线程决定命运。两个定时任务照旧,一个管采样,一个管上报,5 名工人共用一个定时任务线程池(第34夜)。轮询服务也住在同一个池里,它注入的字段名与编排器同款,按名称匹配,落的就是这 5 名工人;事件那一侧整个池里只有一条线程(第30夜)。同一份配置里还立着第二枚池,容量也是 5,从 2019 年 2 月 8 日的第一枚提交起,到今天上游仓库的主干上,没有任何一行代码用过它。同一个傍晚写下两枚 5,一枚天天开工,一枚从未开门。为什么立它,为什么没人用,为什么没人删,几个问题共用同一个答案,人是有限的,能跑就行。这个答案不体面,但是真话。照例补一句边界声明,那枚没人用的池里并没有天天来上班的工人,线程是惰性建制的,没有任务就一个也不启动,天天到场的是池对象本身,每次应用启动露一次面,一来就不走。
谁在看门
第32夜把受理台拆开看过,6 层判断嵌套,一份订购报文在里面被几种话轮番伺候。这一夜往下看一层,看受理台脚下的两张桌子。
受理台身上摊着两张表。第一张,订购报文表,外层按会话键分家,内层按订单号放订购报文。VTN 每发来一份订购报文,受理台把它记进内层表;撤销报文来了,再从内层表里摘掉。第二张,注册报文缓存,会话键指向最近一次收到的注册报文,重注册时整体换新。
两张表的原形,都是普通 HashMap。这里要正一句名。看过第32夜的读者可能以为,并发安全藏在后面某个并发容器里。没有。就是教科书中最常见的 HashMap,内部没有同步,外面也没有互斥锁。它们安全不安全,全看谁在什么时刻摸它们。
摸它们的动作有 3 处,处处是复合动作。复合动作这个词,意思是几步合成一步的事,中间允许别人插队。
第一处,收单。先查外层表里有没有这个会话键,查无就新建一张内层表,把订购报文放进内层表,再把整张内层表放回外层。查、改、放回,3 步。
第二处,撤单。取出内层表,摘掉一个订单号,摘空了连外层键一起摘掉,没摘空就把内层表放回原位。取、摘、放回,又是 3 步。
第三处,重注册。注册报文缓存不做增删,每次整体换一个新引用,旧引用下课,新引用上岗。
3 处动作单独看,一步都没写错。病历要合起来看。
病历 3 页
第一页,收单的先查后建。两名工人同时收单,会话键相同,外层表里都还没有它。两人都查到空,各建各的内层表,各自放入自己的订购报文,然后先后把整张内层表放回外层。后放的覆盖先放的。先那位工人放进内层表的订购报文,连同那张表,从外层表里彻底消失。损失的不是一条记录,是 一整张表。这类病有正式名字,丢失更新,一次写入把另一次写入的结果整个盖掉。
第二页,撤单的摘空摘键。撤单与收单并发。撤单工人取出内层表,摘掉自己的订单号,一看摘空了,把外层键摘掉。可就在它取出内层表与摘键之间,收单工人刚往同一张内层表里放入一个新订单号。摘键一下去,新订单号连同内层表一起蒸发。反过来,摘空判定不成立时把旧表放回,也可能把别人刚换上的新表盖掉。两个方向都是丢失更新。
第三页,重注册的换引用。引用的读与写各自是原子的,读到的半个引用不存在,引用要么是旧的,要么是新的,不会是半个。但两次独立操作之间没有任何约定,写工人换了新引用,读工人可能还在读旧引用,也可能要过很久才看得见新引用。这类病也有正式名字,可见性问题,一个线程改了数据,另一个线程不保证及时看见。
3 页病历,同一个病,正式名字叫数据竞争。两个线程同时读写同一份数据,至少一方在写,先后次序由调度随机决定,结果就不可信。数据竞争不是哪一行写错了,是这一段结构的属性。
为什么 10 年无事
数据竞争要发作,3 样条件缺一不可,共享,可变,并发进门。两张表生来共享可变,前两样写在结构里,第三样不写在代码里,写在部署里。谁来摸这两张表,由报文进门的方式决定。
拉模式部署(第27夜),全部报文排队走轮询。一个 VTN 会话一个轮询任务,固定延迟排程,同一条任务上一次没跑完,下一次绝不开始,事实上的单工人。一名工人前后脚摸表,摸 10000 次也没有第二名工人同时伸手,3 样条件缺了最要命的一样。两张表在这个部署里事实上线程封闭,数据只被一名工人摸到,并发问题从源头不存在。
这就拿到本夜的结论。线程封闭不是数据的属性,是部署形态的属性。同一份代码,同一个 HashMap,换个部署,安全与不安全当场换边,代码一行没改,性质换了。
安全只系在部署上,天然带着一层隐患,部署是别人的决定,不是这段代码的决定。VTN 那边换个网关,换套证书,换个对接方式,这边的部署就可能跟着动。纪律挡不住部署换轨,结构才能挡。第34夜的 4 件结构为什么值得逐件验明,答案在这里,结构不随部署换,部署随时会换。
这一段讲完,有一段话要原样放在这里。
真不知道为啥上游要搞这么一段僵尸代码在那,真是无语!
就好比一个人天天坐在工位上,天天来公司,但纯粹不干活,因为没活给他干。所以说,我们关心的都是业务。你想想,代码不是你搭的,框架也不是你搭的,你根本不熟悉,读懂它的纯业务逻辑已经很费劲了,你还得去看它的配置。配置方面,HTTPS 的安全验证、接口的交互、端口、双开这些,已经把我搞得头疼脑胀了,哪有心情管这些啊?
这两段话讲破了太平的人间那一半。两张表在拉模式部署下太平了 7 年,不是有人验过它们,是没有人有理由路过。读代码的预算花在业务上,配置层住在预算到不了的楼层。一段代码的安危,先看它有没有被看见。
3 个开关
报文进门有分发器正身,按报文类型分派给各服务。分发器面前 3 条路,3 条路 3 套线程模型。
第一条路,拉模式。轮询任务把 VTN 递来的报文取回,分发器分派,受理台处理完,应答不顺着原路回去,而是另起一份新报文送出去(第27夜的两程执行,就在这里落地)。全程跑在轮询任务线程上,5 名工人之一。
第二条路,推模式。VTN 的报文直接投到 VEN 的 HTTP 端点,分发器在请求线程里分派,受理台处理完,应答在同一条请求线程里写回响应体。开工的不是那 5 名工人,是 HTTP 服务器自己的工人池。有多少工人,就有多少潜在的并发进门。
第三条路,XMPP,报文走消息总线,收发各走各的通道。本夜不展开,只留一个名字。
3 个开关,就是 3 条路的换轨钮,外加一个维度。
开关一,推模式。报文不再等轮询,HTTP 工人并发直进受理台。10 年不遇的并发进门,从这一刻起天天有。
开关二,多会话。外层表按会话键分家,看着像隔离。分家挡得住的只有一种相撞,不同会话的复合动作各动各的内层表,先查后建互不相干。挡不住的有两层。一层在组合里,会话多了,同一个会话的两条报文在推模式下照样可能并发进门,同键的先查后建相撞跟着涨。另一层在更底下的结构,所有会话的键值对都长在同一张普通 HashMap 上,并发放回多了,这张表自己的扩容搬家就要在并发里进行,条目可能丢在半路。分家分的是逻辑地盘,底下的表只有一张。
开关三,重注册。注册流与上报流并行,注册报文换引用,订购报文收单撤单,两股流在两张表上交织。重注册密集期,就是 3 页病历的集中发作期。
3 个开关不挑拨法。一次部署换轨可以同时拨动全部 3 个,VTN 从拉改推、再加多会话,是市场上一句常见的需求。
恢复风暴
接下来的风暴是推演,不是某一次事故的实录。真假两层先记清楚,触发条件与病理是真的,每一条都能在代码里指认,节奏与场景是编的,演绎层的事。
剧本开场。VTN 侧一台机器重启,或者一条链路抖动。按协议规则,恢复之后要重新注册,重新注册会带动重新订购。重注册不是一条报文,是一簇。这一簇里,订购报文涌向受理台,收单的先查后建在并发进门下高频触发,内层表成簇蒸发。
同一时刻,工坊那一侧一切照旧。采样任务照常向跳表放读数,上报任务照常取窗发货。工坊住在编排器自己的并发容器里,与受理台的两张表互不相干。受理台丢了什么,工坊不知道,也不需要知道。
蒸发的条目不报警。没有异常,没有日志,没有重试。它们要在很久以后才现形,撤销报文来撤一个已蒸发的订单号,受理台查无此单,回一个 453;或者下一次注册应答附上存量清单,少掉的订单号在清单缺口里露出马脚。到那时,距离丢失已经不知隔了多少窗。
平时低频,发作成簇,损坏静默。这 12 个字是数据竞争在工业现场的签名。低频时它不存在,成簇时它集中兑现,兑现时它一声不响。
演示件
演示件 RegistryStorm 把受理台两张表缩进一个文件,一件代码两跑。形态一,单工人,顺序执行 10000 笔收单、5000 笔撤单、两百次重注册,清点分毫不差。形态二,三开关全开,3 名工人并发进门,两名工人同时首建同一张会话表,复现先查后建的丢失更新,同期工坊照常生产。
| 真身 | 演示件 | 说明 |
|---|---|---|
| 受理台两张表,普通 HashMap | 同构,无互斥锁 | 结构一致 |
| 会话键 sessionKey | VTN-A 与 VTN-B | 同一种键位分家 |
| 先查后建窗口纳秒级 | 停一拍一行,窗口打到毫秒级 | 追光只开在并发回合 |
| 蒸发条目在撤销时报 453 | 点名第一条蒸发的订单号 | 同一种静默 |
| 工坊住在编排器自己的并发容器 | 上报计数照常累加 | 生产与清点分家 |
java
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 演示件 RegistryStorm:受理台两张表的仿制模型,一件代码两跑。
*
* 真身对照(Oadr20bVENEiReportService.java,结构仿制,代码自写,零照录):
* 一、收单:先查外层表,查无新建内层表,放入条目,再把整张内层表放回外层,三步复合动作与真身同构;
* 二、撤单:取出内层表,摘条目,摘空连外层键一起摘,未摘空整表放回,与真身同构;
* 三、注册缓存:每次重注册整体换新引用,与真身同构;
* 四、两张表都是普通 HashMap,全程无互斥锁,与真身同构;
* 五、演示在查与改之间加了一次停一拍(Thread.sleep(1)),把先查后建的窗口打到毫秒级,
* 真身没有这一拍,窗口只有纳秒级;结构相同,概率不同,相当于给现场打了一盏追光,
* 追光只开在并发回合,单工人回合不开,跑的就是原味窗口。
*/
public class RegistryStorm {
/** 订单表,外层按会话键分家,内层按订单号放订购报文。外层内层都是普通 HashMap,真身同构。 */
static final Map<String, Map<String, String>> orderTable = new HashMap<>();
/** 注册报文缓存,会话键指向最近一次收到的注册报文,重注册时整体换新引用。真身同构。 */
static final Map<String, String> registerCache = new HashMap<>();
/** 收单记录,收过的每一笔都在这里,清点时表里必须找得到。并发容器,只增不减,这是本件自家的底气。 */
static final Map<String, AtomicLong> taken = new ConcurrentHashMap<>();
/** 撤单记录,合法撤掉的每一笔也都在这里,清点时要从总数里扣掉。与收单记录同款并发容器。 */
static final Map<String, AtomicLong> dropped = new ConcurrentHashMap<>();
/** 上报计数,工坊一侧的生产记录,每跳一格记一笔,只增不减。 */
static final AtomicLong reported = new AtomicLong();
/** 追光开关,只给并发回合开。真身没有这一拍。 */
static volatile boolean spotlight = false;
/**
* 收单,真身的三步复合动作,先查,后改,整表放回。
* 查与改之间的停一拍是演示追光,真身没有这一拍。
*/
static void takeOrder(String session, String orderId, String payload) {
Map<String, String> inner = orderTable.get(session); // 第一步,先查
if (inner == null) {
inner = new HashMap<>(); // 查无,新建内层表
}
if (spotlight) { // 追光,把窗口张开,真身无此拍
try {
Thread.sleep(1);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
inner.put(orderId, payload); // 第二步,后改
orderTable.put(session, inner); // 第三步,整表放回
taken.computeIfAbsent(session, k -> new AtomicLong()).incrementAndGet();
}
/**
* 撤单,真身的复合动作,取出内层表,摘条目,摘空摘键,未空放回。
*/
static void dropOrder(String session, String orderId) {
Map<String, String> inner = orderTable.get(session);
if (inner != null) {
inner.remove(orderId);
if (inner.isEmpty()) {
orderTable.remove(session); // 摘空,连外层键一起摘
} else {
orderTable.put(session, inner); // 未摘空,整表放回
}
}
dropped.computeIfAbsent(session, k -> new AtomicLong()).incrementAndGet();
}
/** 重注册,注册报文整体换新引用。真身同构。 */
static void swapRegister(String session, String payload) {
registerCache.put(session, payload);
}
/**
* 清点,收单总数减去合法撤单数,再减去订单表现存条目数,差值就是蒸发的条目。
*/
static long auditTaken() {
long missing = 0;
for (String session : taken.keySet()) {
long takenCount = taken.get(session).get();
long droppedCount = dropped.containsKey(session) ? dropped.get(session).get() : 0;
Map<String, String> inner = orderTable.get(session);
int present = (inner == null) ? 0 : inner.size();
missing += takenCount - droppedCount - present;
}
return missing;
}
public static void main(String[] args) throws Exception {
System.out.println("== RegistryStorm:受理台仿制模型,一件代码两跑 ==");
System.out.println("两张表与真身同构,普通 HashMap,无互斥锁;追光停一拍只开在并发回合。");
// ---------- 形态一,单工人 ----------
// 一条线程顺序执行一万笔收单、五千笔撤单、两百次重注册。
// 这是拉模式单会话部署的仿制,同一时间只有一名工人摸表,追光不开,原味窗口。
taken.clear();
dropped.clear();
orderTable.clear();
registerCache.clear();
reported.set(0);
spotlight = false;
for (int i = 0; i < 10000; i++) {
String session = (i % 2 == 0) ? "VTN-A" : "VTN-B";
takeOrder(session, "ORDER-" + i, "order#" + i);
if (i % 2 == 1) {
dropOrder("VTN-A", "ORDER-" + (i - 1));
}
if (i % 50 == 0) {
swapRegister(session, "register#" + i);
}
}
long missing1 = auditTaken();
System.out.println();
System.out.println("[形态一 单工人] 收单 10000 笔,撤单 5000 笔,重注册 200 次,清点缺失 "
+ missing1 + " 笔" + (missing1 == 0 ? ",分毫不差。" : ",出事了。"));
// ---------- 形态二,三开关全开 ----------
// 三名工人并发进门,开关一推模式;两个会话键,开关二多会话;主线程穿插重注册,开关三。
// 每一回合主线程先清场,保证人人查空,再放行三名工人同时首建,
// 复现先查后建的并发首建竞态。工坊一侧的上报计数照常累加,生产不停。
taken.clear();
dropped.clear();
orderTable.clear();
registerCache.clear();
reported.set(0);
spotlight = true;
int rounds = 500;
long expectedReports = 2L * rounds;
long concurrentOrders = 3L * rounds;
long missing2 = 0;
String vanishedId = null;
int vanishedRound = -1;
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int r = 0; r < rounds; r++) {
CountDownLatch gate = new CountDownLatch(1); // 发令枪
CountDownLatch done = new CountDownLatch(3); // 收工哨
orderTable.clear(); // 主线程清场,本回合人人查空
String roundTag = "R" + r;
for (int w = 0; w < 3; w++) {
final String session = (w < 2) ? "VTN-A" : "VTN-B";
final String orderId = roundTag + "-W" + w;
final boolean report = (w % 2 == 0); // 工人零与工人二兼跑上报
pool.submit(() -> {
try {
gate.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
if (report) {
reported.incrementAndGet(); // 上报一跳,工坊照常生产
}
takeOrder(session, orderId, "order@" + roundTag);
if (!report) {
swapRegister(session, "register@" + roundTag); // 工人一兼跑重注册
}
done.countDown();
});
}
gate.countDown(); // 三名工人同时进门
done.await(5, TimeUnit.SECONDS);
// 回合末清点。两名工人同时首建同一张会话表,后放回的整表覆盖先放回的,
// 会话键 VTN-A 每回合要蒸发一条;VTN-B 单人收单,无竞态。
Map<String, String> innerA = orderTable.get("VTN-A");
int presentA = (innerA == null) ? 0 : innerA.size();
Map<String, String> innerB = orderTable.get("VTN-B");
int presentB = (innerB == null) ? 0 : innerB.size();
int roundMissing = (2 - presentA) + (1 - presentB);
missing2 += roundMissing;
if (roundMissing > 0 && vanishedId == null) {
for (int w = 0; w < 2; w++) {
String id = roundTag + "-W" + w;
if (innerA == null || !innerA.containsKey(id)) {
vanishedId = id;
vanishedRound = r;
}
}
}
}
pool.shutdown();
pool.awaitTermination(5, TimeUnit.SECONDS);
spotlight = false;
System.out.println();
System.out.println("[形态二 三开关] 回合 " + rounds + ",并发进门 " + concurrentOrders
+ " 人次,清点缺失 " + missing2 + " 笔。");
if (vanishedId != null) {
System.out.println("[形态二 三开关] 蒸发示例," + vanishedId + " 在第 " + vanishedRound
+ " 回合收单成功,回合末已不在表内。此刻撤销它,真身将回查无此单。");
}
System.out.println("[形态二 三开关] 同期工坊上报 " + reported.get() + "/" + expectedReports
+ " 跳,全勤。少的是清点上的条目,不是心跳上的跳数。");
System.out.println();
System.out.println("== 两跑收工 ==");
System.out.println("同一份代码,换个部署形态,清点从分毫不差到条目蒸发。");
System.out.println("工人没报错,工坊没停跳,少的条目只在表里。");
}
}
JDK 21 单文件可跑,运行输出随稿在案。
== RegistryStorm:受理台仿制模型,一件代码两跑 ==
两张表与真身同构,普通 HashMap,无互斥锁;追光停一拍只开在并发回合。
[形态一 单工人] 收单 10000 笔,撤单 5000 笔,重注册 200 次,清点缺失 0 笔,分毫不差。
[形态二 三开关] 回合 500,并发进门 1500 人次,清点缺失 500 笔。
[形态二 三开关] 蒸发示例,R0-W1 在第 0 回合收单成功,回合末已不在表内。此刻撤销它,真身将回查无此单。
[形态二 三开关] 同期工坊上报 1000/1000 跳,全勤。少的是清点上的条目,不是心跳上的跳数。
== 两跑收工 ==
同一份代码,换个部署形态,清点从分毫不差到条目蒸发。
工人没报错,工坊没停跳,少的条目只在表里。
对着输出读 3 个细节。第一,形态一与形态二跑的是同一份代码,一行没改,清点结果从分毫不差到条目蒸发,安全来自部署形态,不是来自代码。第二,形态二清点缺失恰好等于回合数,每回合蒸发的都是 一整张内层表,损失集中在一个会话键上,丢的从来不是一条,是一张。第三,同期上报计数满勤,全程没有一个异常,生产与清点彻底分家,这正是风暴最难防的一点,坏处只在盘点时现形。
结论
第34夜问,报告侧凭什么敢无锁。结构那一半,4 件结构逐件验明;部署那一半,这一夜验完。受理台两张表,3 处复合动作,共享、可变、并发进门,3 样凑齐就是数据竞争。拉模式单会话把第三样摁在门外,7 年太平。3 个开关,推模式、多会话、重注册,拨动任何一个,第三样进门,风暴按剧本兑现,平时低频,发作成簇,损坏静默。少的是清点上的条目,不是心跳上的跳数。
线程封闭不是数据的属性,是部署形态的属性。风暴过后总有人来撤单。撤单这一条链自己也藏着几处机关,一份订购的生死,下一夜。
① 真伪核对
- 受理台两张表为普通 HashMap 与 3 处复合动作(收单先查后建、撤单摘空摘键、注册缓存换引用),真身源码实读;行号不入稿(行号隐私令),类名方法名照录(脱敏)。
- 轮询服务与编排器共用一个定时任务线程池,轮询服务注入的字段名与配置 bean 同名,按名称匹配,源码实证。
- 第二枚池出生即无消费方,上游第一枚提交(2019 年 2 月 8 日)已含该池,当时事件侧确有定时任务但注入的是共享池;时间线出生提交(2020 年 11 月 10 日)自带容量一的线程池;上游主干今日两池并存,多仓库检索无消费方。
- 分发器 3 条路 3 套线程模型(拉模式两程另起新报文、推模式同请求线程写回响应体、XMPP 走消息总线),分发器与轮询服务源码实读。
- 数据竞争、丢失更新、可见性、线程封闭诸词出自并发编程经典;HashMap 无内部同步为官方文档声明。
- 风暴剧本为演绎层推演,触发条件与病理有源码实证,节奏与场景为编(正文已声明);重注册带动重新订购为协议注册流程语义。
- 演示件两张表与真身同构(普通 HashMap 无互斥锁);停一拍一行仅演示件有,真身窗口纳秒级为推断表述(源码无此拍);形态一清点缺失 0、形态二清点缺失 500、蒸发示例、上报满勤,均为运行输出实录(run35.txt 随稿在案)。
- 口供两段为 David 今日口述原话原样录(口述原样铁则),僵尸措辞照录。
- 453 查无此单为协议应用层错误码语义(撤销对不存在订单号的回应),第32夜已录,回门。
② 术语对照
| 术语 | 本夜含义 |
|---|---|
| 复合动作 | 几步合成一步的事,中间允许别人插队 |
| 数据竞争 | 两个线程同时读写同一份数据,至少一方在写,先后次序随机,结果不可信 |
| 丢失更新 | 一次写入把另一次写入的结果整个盖掉 |
| 可见性 | 一个线程改了数据,另一个线程不保证及时看见 |
| 线程封闭 | 数据只被一个线程摸到,并发问题从源头不存在,安全性随部署形态不随代码 |
| 受理台 | 第32夜正名,订购报文的受理逻辑,本夜看它脚下的两张桌子 |
| 追光停一拍 | 演示件手法,在查与改之间停一拍把窗口打到毫秒级,真身无此拍 |
| 查无此单 | 453,撤销报文对不存在订单号的回应 |
③ 今夜习题
Ⅰ 两名工人同时收单,会话键相同且是外层表里没有的新键,收单 3 步为先查、新建、放回。问外层表最终有几张内层表、几条订购报文,蒸发了什么。再问,两人收的是不同会话键时,先查后建的相撞还在不在,为什么。
Ⅱ 4 种部署,逐一判断受理台两张表是否安全并说理由。一,拉模式单会话。二,拉模式多会话。三,推模式单会话。四,推模式多会话且重注册密集。
Ⅲ 把收单 3 步改成并发容器的原子写法(提示,ConcurrentHashMap 的 compute 一把收口),重跑演示件的并发回合,清点缺失是多少。再答一句,锁是补丁,结构是堤坝,在这道题里,补丁与堤坝各指什么。
本书目录导航 上一篇:算法一千零一夜 · 第三十四夜 · 采样与上报的旋律 下一篇(载锅中) 起点:卷首语·算法童话
版权声明:本文为作者原创,受著作权法保护。未经授权禁止转载、搬运、摘编、改编及任何形式的二次创作;个人学习引用请注明作者与原文出处。转载授权请联系作者(CSDN 私信)。侵权必究。