原创 石涛声&曹洪伟 2026-10-22 20:26 北京

我们用了二十多年年时间学会了怎么把系统拆小,却始终没学会该往哪里下刀。这篇文章想说明:刀口的位置,五十年前就有人写清楚了。
【缘起】多年前,石头兄弟提出了一个问题“微服务的复杂性到底是什么”,我并没有答案,但答案允许迟到,但不会缺席。
我们花了很长的时间学会了怎么把系统拆小,却始终没学会该往哪里下刀。这篇文章想说明:刀口的位置,五十年前就有人写清楚了。
第一,复杂性不等于规模。一枚 5nm 芯片上有 153 亿个晶体管,人类可以设计、制造并控制它;一家公司的代码只有二十亿行,却会常年带着万分之二的崩溃率运转。差别不在数量级,而在部件之间有没有清晰的边界和有限的相互影响。
第二,模块化之所以有效,不是工程习惯,而是可以被写成不等式的。把两个问题放在一起解决,其复杂度高于分别解决之和;由此推出工作量的不等式。但模块不能无限拆——集成成本随模块数量上升,总成本曲线是个 U 形,最优点在中间某处。
第三,怎么找到那个"中间某处",帕纳斯在 1972 年给了准则。划分单位不是处理步骤,而是"困难的设计决策"和"容易变化的设计决策"。模块的职责是把这些决策藏起来。微服务把这条准则从函数级推到了进程级,收益和代价都被同比例放大了。
引子:两个数字
先看两组数字。
2015 年,谷歌统计自家所有产品的代码,加起来约 20 亿行。2018 年,阿里巴巴的程序员一年写下 12 亿行代码。2020 年,华为的麒麟 9000 芯片,在 5nm 工艺上集成了 153 亿个晶体管。
数量级是相近的,甚至芯片那边更多。
但我们对这两样东西的掌控力,完全不在一个水平上。芯片从设计、流片到量产,有完整的验证链条,良品率是可以被预测和提升的;而一个日活千万级的 App,即便崩溃率已经做到业内优秀的万分之二,仍然会源源不断地冒出莫名其妙的 bug——无法复现,或者改完之后别处又坏了。
同样是"亿"级的组成单元,为什么一个能被工程化地控制,另一个不能?
这个问题指向软件工程里最实在的一处结构性差异,也是本文想讨论的全部内容:复杂性不是由部件的数量决定的,而是由部件之间的关联方式决定的。
一、"复杂"这个词的三层含义
1.1 词典给的三个条件
讨论之前先澄清。牛津词典对 complex 的释义其实给了三个条件,缺一不可:
由多个部分或事物组成;
这些部分之间是有相互关联的;
整体因此不便于理解。
第一条讲数量,第二条讲关系,第三条讲认知后果。日常讨论里最常被忽略的是第二条——大家习惯用"东西多不多"来衡量复杂,而真正制造麻烦的是"事物之间连了多少条线"。
1.2 庞杂与复杂,不是一回事
有一本书叫《为什么需要生物学思维》,里面做了一个区分,值得借用:
这个区分在工程上很好用。一个仓库里堆了三千个文件,很乱,但它是庞杂的——你可以一个一个看过去,顶多是花点时间。而一个只有三十个服务的系统,如果每个服务都能直接读写另外五个服务的数据库,它就是复杂的——你改一处,可能不知道哪里会有影响。
维度 | 庞杂 | 复杂 |
主要来源 | 元素数量 | 元素间的关联与反馈 |
增长方式 | 线性累加 | 组合爆炸、级联放大 |
可分解性 | 可以逐项处理 | 拆开后行为可能改变 |
典型后果 | 费时间 | 无法归因、无法预测 |
软件例子 | 一个巨大的工具类文件 | 三十个服务共享五张表 |
一旦系统跨过庞杂到复杂的那条线,它就会变成一个既无法控制、也难以理解的东西。这个状态,可以叫"复杂性灾难"。
1.3 级联:复杂性的放大器
为什么关联比数量更致命?因为关联带来的是组合,不是加法。
假设系统里有 n 个部件,两两之间可能发生影响,那么这个影响关系最多有 n(n-1)/2 条。n=10 时是 45 条,n=1000 时接近 50 万条。更要命的是,软件里的影响往往是分层的:函数调函数,模块调模块,服务调服务,每一层都有自己的级联。层与层叠加之后,可能出现的交互路径数量会迅速超出任何一个团队的理解能力。
有一句话说得直白:几百上千万行代码,一旦发生互相之间的关联互动,而且是一层一层的不同级别的互动,"产生的情况有多少种呢?可能比整个宇宙的粒子数量还要多"。
这不是夸张,是组合数学的常识。宇宙可观测部分的粒子数大约 10^80,而一个三十服务、每个服务暴露二十个接口的系统,其调用路径的组合数在考虑重试、超时、并发之后,轻易就能逼近甚至超过这个量级。
所以真正的问题从来不是"我们的代码有多少行",而是"我们的代码之间有多少条没人知道的线"。
二、复杂性灾难:当系统无法被归因
2.1 三个案例
要理解"复杂性灾难"到底是什么样子,看三个事故比看定义有效。
1986 年 1 月 28 日,挑战者号航天飞机在升空 73 秒后解体。调查委员会在当年 6 月提交报告,原因指向固体助推器上的 O 形密封圈:低温发射时橡胶失去弹性,燃气泄漏烧穿了外贮箱。物理学家费曼做了一个后来被反复引用的演示——把一段 O 形圈丢进一杯冰水,再用 C 形夹压住,松手后它没有弹回来。结论明确,责任明确,甚至可以复现。
1996 年 6 月 4 日,阿丽亚娜 5 号火箭首飞,升空约 37 秒后偏离航线,随即自毁解体。调查结论是:箭上惯导系统沿用了阿丽亚娜 4 号的软件,其中有一段把 64 位浮点数转换成 16 位有符号整数的代码。阿丽亚娜 5 的横向加速度比 4 号大得多,这个转换发生了溢出;溢出触发异常,异常导致主备两套惯导先后关机,火箭随即失控。这段代码在 4 号的多年服役中从未出过问题——它不是一个 bug,它是一个在新环境里失效的旧假设。这次失败损失了两颗卫星,代价约 3.7 亿美元。
2009 年前后,丰田在美国因"意外加速"发起大规模召回。调查持续了数年,结论并不统一:2011 年 NASA 受委托完成的工程分析,未发现电子节气门系统存在可复现的软件缺陷;而 2013 年俄克拉荷马州一起案件的陪审团,认定车辆的电子控制系统存在缺陷。同一套系统,同一批事实,专业机构之间给出了不同的判断。
2.2 归因失效才是灾难的本质
把三个案例排在一起,会看到一个清晰的梯度:
事故 | 能否定位到单一部件 | 能否复现 | 责任能否归属 |
挑战者号(1986) | 能,O 形密封圈 | 能 | 能 |
阿丽亚娜 5 号(1996) | 部分能,一段复用代码 | 能(仿真) | 难,无人被追责 |
丰田意外加速(2009–) | 不能 | 不能 | 不能 |
第一起是工程失败:系统足够复杂,但边界清楚,所以能被分解、被定位。第二起已经开始变质:出问题的不是某个零件,而是"旧代码在新参数下依然成立"这个假设,而假设散落在系统的语义里,没有物理位置。第三起则完全进入了复杂性灾难的范畴:问题存在于软件系统与外部机电系统的大规模交互之中,任何一个单点看上去都没错,整体却出了人命。
这正是复杂性灾难的定义性特征:它不是"某个地方坏了",而是"没有任何一个地方单独坏掉"。
有一句话被反复引用:雪崩时,没有一片雪花是无辜的。它的反面同样成立——雪崩时,因为没有一片雪花是无辜的,所以也没有一片雪花是需要负责的。这句话的工程含义非常冷酷:当系统复杂到无法归因,你也就失去了通过追责来改进系统的能力。
2.3 为什么软件比硬件更容易掉进去
物理设备之间的边界是清晰的。一根轴的公差是 0.01 毫米,一个接口的扭矩上限是清晰的,这些都是可以测量、可以验收、可以在图纸上标注的。而代码与代码之间的"边界",往往只存在于写它的人脑子里。
更麻烦的是,软件没有物理约束来兜底。机械系统过载会变形、会发热、会断,物理定律替你做了限制;软件过载只是慢一点,然后在一个你没预料到的地方超时、重试、放大,最后把上下游打垮。物理世界用磨损提醒你系统在老去,软件则倾向于在崩溃之前一直"看起来正常"。
所以,软件工程师和机械时代的工程师,处境其实很不一样。后者画蓝图、按图施工、精确控制,造出一个系统,他就是这个系统的神。前者一行行写下系统,却远远不是神——总有一些控制不住的东西,比如一辈子都要打交道的 bug。这不是工程师不够优秀,是这类系统的性质决定的。
顺带说一句移动端。移动开发长期被认为"复杂度可控",原因是它建立在相当成熟的框架之上,大量工作是 UI 构建和与服务端的信息交换,业务相似度高、重复度高。但这不是逃过了复杂性,只是把复杂性爆炸的时间点推后了:随着业务量增长,偶发崩溃、不可复现的问题一样会出现。
三、量级不等于复杂度
回到引子里的对比。三个数字放在一起看很有意思:
对象 | 组成单元数量 | 时间 | 可控性 |
谷歌全部产品代码 | 约 20 亿行 | 2015 | 中,靠工程体系维持 |
阿里巴巴年新增代码 | 约 12 亿行 | 2018 | 中 |
麒麟 9000 晶体管 | 约 153 亿个 | 2020 | 高,可设计可验证 |
波音 747 零件 | 约 600 万个,275 公里管线 | — | 高,可靠性以百万架次计 |
波音 747 有六百万个零件、两百七十五公里长的管线,世界上没有任何一个人能彻底搞清楚它的完整构造。按演讲中引用的统计口径,它的致命事故率约为每百万架次 1.6 起,安全性最高的机型可以做到 0.33 起——这个水平比绝大多数 App 的"事故率"要低得多。
原因不在于飞机比软件简单,而在于大型物理系统具备四个可复制的特征:
精准完备的设计:图纸先于制造,改动要走变更流程;
清晰的模块边界:发动机、液压、航电,物理上就是分开的;
明确的、有限的相互关联:接口是标准件,连接是 enumerated 的;
可控的变更:改一个部件,需要重新验证的清单是已知的。
软件很难做到第一条——需求在变,技术在变,很少有系统能在开工前把设计做完备。但后三条是可以努力靠近的,而且不需要等待任何新技术:清晰化模块边界,减少相互关联以降低级联效应,把变更关进笼子里。
这才是本文真正的落点。下面的内容,基本都是这三句话的展开。
四、模块化:一个可以写成公式的直觉
4.1 两个不等式
"分层和模块化是解决复杂问题的基本方案"——这句话大家都听过,但很少有人追问为什么。其实它可以被写得很朴素。
设 c 表示问题的复杂度(包含问题现状及其可能的发展变化),w 表示解决它所需的工作量。那么:
if c(k) > c(p) then w(k) > w(p)
翻译成人话:复杂问题花的时间比简单问题多。这几乎不证自明。
关键在第二步。当两个不同的问题被放在一起解决时,其复杂度通常高于分别解决之和:
c(k + p) > c(k) + c(p)
因为放在一起,就多出了"两者之间如何相互影响"这一层,而这一层本身是有成本的。代入第一个不等式,得到:
if c(k + p) > c(k) + c(p) then w(k + p) > w(k) + w(p)
两个问题合起来做,工作量大于分开做。这就是模块化的全部理由:它把一个大问题切成若干小问题,让工作量从"大于和"回到"接近和"。顺带还带来一个社会性收益——切开的块可以并行,多人协作因此成为可能。大规模软件之所以存在,前提就在这里。
4.2 但模块不能无限拆
既然拆分能降低成本,为什么不拆到最细?
因为上面那个不等式只算了一侧。拆分本身有成本:模块越多,接口越多,集成就越贵。集成成本大致随模块数量超线性上升,而单个模块的开发成本随模块数量下降。两条曲线相加,总成本是一个 U 形曲线。
模块数量 | 单模块成本 | 集成成本 | 总成本 |
很少 | 高(问题未被分解) | 低 | 高 |
适中 | 中 | 中 | 最低(最小成本区间) |
很多 | 低 | 高(接口爆炸) | 高 |
日常开发中我们其实一直在描这条曲线:既不会把整个系统写成一个文件,也不会把一个函数拆成十个服务。所谓"架构能力",很大程度上就是对这条曲线最低点的判断力。
那么问题来了:最低点在哪里?依据什么下刀?
这就是 1972 年那篇论文要回答的事。
五、1972 年:分解的准则
5.1 一位容易被忽略的作者
David Lorge Parnas,1941 年生,电气工程博士,是最早把传统工程原理系统性地引入软件设计的人之一。他是首届图灵奖得主 Alan Perlis 的博士生,也是"信息隐藏"(information hiding)这个概念真正的提出者。
值得一提的是,我们今天熟悉的"高内聚、低耦合",帕纳斯本人几乎不用。他用的是另一个词:信息隐藏。这两个提法描述的是同一件事的不同侧面,但帕纳斯的版本更可操作——它告诉你该怎么下刀,而不只是告诉你刀口应该漂亮。
他还是"星球大战"计划(SDI)的早期参与者,也是它最著名的公开批评者之一。1985 年,他发表文章论证:用于作战管理的软件不可能达到可以被信任去阻止核攻击的质量水平。这个判断的方法论基础,和他 1972 年那篇论文是同一套。
5.2 那篇论文和它的问题
1972 年 12 月,Parnas 在《Communications of the ACM》上发表《On the Criteria To Be Used in Decomposing Systems into Modules》。这篇论文讨论的问题极其具体:把系统拆成模块时,到底应该按什么标准拆?
论文用了一个贯穿全文的例子:KWIC(Key Word In Context)索引系统。需求是这样的:
系统接受若干行文本,每行由若干词组成,每个词由若干字符组成。每一行要做循环移位——反复把第一个词移到行末;然后把所有行、所有移位结果按字母顺序排列输出。
举例来说,输入两行:
Clouds are white
Ottawa is beautiful
输出要长这样,每个关键词都被它所在的上下文包围:
are white Clouds
beautiful Ottawa is
Clouds are white
is beautiful Ottawa
Ottawa is beautiful
这个问题简单,但包含了一个完整系统的所有要素:输入、数据结构、变换、排序、输出。用它来比较两种分解方式,非常干净。
5.3 方案一:跟着流程图走
第一种分解是最符合直觉的,也是几乎所有工程师默认会做的那一种:先画流程图,然后把每个处理步骤变成一个模块。
于是得到五个模块:
模块 | 职责 |
Input | 读入数据行,存进 core;存储格式为每机器字 4 个字符,并维护一个指向各行起始位置的指针数组 |
Circular Shift | 在 Input 完成后调用;读行存储,生成一个"对"的数组(每个循环移位的首字符下标、原行号) |
Alphabetize | 在 Circular Shift 完成后调用;读上述两个数组,生成新的索引 |
Output | 在排序完成后调用;读模块 1 和模块 3 产出的数组,漂亮地打印出来 |
Master Control | 负责前四个模块的时序与错误处理 |
这套设计能跑,功能正确。请注意:模块之间不是通过接口通信的,而是通过共享存储。Characters、Index、Alphabetised Index 三块数据结构是公共的,每个模块都直接读写它们。Output 模块的实现,必须知道 Index 里存的是"指向 Characters 的地址",也必须知道 Alphabetize 把结果按什么顺序摆好。
在那个内存只有几 KB 的年代,这样的设计不仅是合理的,甚至是必要的——你必须精心设计字节排列和打包方式,才能把数据塞进去。这些关于存储格式的决策,本身就是设计的主体。
5.4 方案二:跟着变化走
第二种分解放弃了流程图。它给出的模块是这样的:
模块 | 职责 |
Line Storage | 一组函数:CHAR(r,w,c) 返回第 r 行第 w 个词的第 c 个字符;SETCHAR 设置它;WORDS(r) 返回词数…… |
Input | 从输入介质读原始行,调用 Line Storage 存起来 |
Circular Shifter | 提供与模块 1 同构的一组函数:CSCHAR、CSWORDS、CSLINES、CSCHARS,外加上电时调用的 CSSETUP |
Alphabetizing | ITH(i) 返回按字母序排第 i 位的循环移位下标;使用前必须先调 SORT() |
Output | 打印行或循环移位的集合 |
表面上看,模块名字差不多,甚至数量都还是五个。但结构完全不同,关键差异只有一条:底层数据不再共享,所有访问都必须经过模块自己的接口。
除了 Line Storage 自己,没有任何模块知道行是怎么存的、是不是每机器字打包四个字符、循环移位到底是真存了一份还是每次现算。Alphabetizing 甚至被设计成让调用方无法察觉排序究竟有没有真的做完——它可以在 SORT() 里全部算完,也可以在每次 ITH(i) 调用时临时算一点。
这就是信息隐藏。模块不再是"一个处理步骤",而是"一组被藏起来的设计决策"。
5.5 三把尺子
两种方案都能正确实现功能,也都在一定程度上拆解了复杂性。论文用三把尺子来比较它们。
第一把:可变性。论文列了五条在真实演进中很可能发生的变更:
变更 | 方案一的影响面 | 方案二的影响面 |
输入格式变更 | 限于 Input 模块 | 限于 Input 模块 |
全部行常驻内存改为不常驻 | 每个模块都要改 | 限于 Line Storage |
字符打包方式变更 | 所有模块都要改,因为都依赖 core 的存储格式 | 只有 Line Storage 知道 |
循环移位从"建索引"改为"实存" | 字母排序器和输出例程都要改 | 限于 Circular Shifter |
排序时机从"预先全排"改为"按需计算" | 很麻烦,Output 假定索引已经就绪 | 限于 Alphabetizing,外部无感 |
除了第一条,其余四条在方案一里都会穿透到多个模块,在方案二里都被关在一个模块内。差异的来源很清楚:方案一把"存储格式怎么办、排序什么时候做"这些决策暴露在了接口上;方案二把它们藏在了接口后面。
第二把:并行独立开发。方案一的模块接口是"复杂的格式和表组织结构",这些格式本身就是不能轻视的设计决策,必须由几个小组共同商定,而且要仔细设计——接口定不下来,谁也不能开工。方案二的接口更抽象,主要是函数名加上参数的数量和类型,都是相对简单的决策,独立的模块开发可以更早开始。
第三把:可理解性。要理解方案一的 Output 模块,你必须先了解 Circular Shifter、Alphabetizer 和 Input 在做什么——只有在其他模块以特定方式工作的前提下,输出所用的表结构里某些字段才有意义。这个系统只能作为一个整体被理解。而在方案二里,Output 只需要调用一个简单接口。
一句话总结:方案一是"按时间顺序切",方案二是"按知识的边界切"。
5.6 Parnas的结论
论文的结论说得很不客气:从流程图入手把系统分解为模块,几乎总是不妥的。
正确的起手式不是画流程,而是先列出"一系列困难的设计决策,或者可能变化的设计决策",然后让每个模块去隐藏其中的一部分。模块的接口设计原则也随之确定:尽可能少地暴露内部工作原理。
这里有一个常被忽略的判断:流程图对五千到一万条指令规模的系统是个有用的抽象,但超过这个量级,它就不够用了。这不是流程图本身的错,而是因为流程图表达的是"控制流",而大规模系统的麻烦几乎都长在"数据与知识的依赖"上。
六、布鲁克斯的认错
这套理论靠不靠谱?有一个旁证非常有说服力。《人月神话》的作者 Fred Brooks,在书里说过一句被引用得极多的话:给我看你的流程图而藏起你的数据表,我仍然会迷惑;给我看数据表,我通常就不需要流程图了,程序结构会变得很明显。
这句话常被用来支持"数据结构优先",但它其实也埋下了对信息隐藏的怀疑:如果数据表才是理解系统的钥匙,那把数据藏起来,别人还怎么理解?所以在《人月神话》第一版里,Brooks 批评了信息隐藏,他推崇的是公开共享代码。
二十年后的 1995 年,在 20 周年纪念版里,他专门用一小节更正了这个判断。原话是:
Parnas was right, and I was wrong about information hiding. (…) I am now convinced that information hiding, today often embodied in object-oriented programming, is the only way of raising the level of software design.
(……)[传统的]技术确保程序员可以通过知道另一边是什么,来知道他们所用接口的详细语义。隐藏这些语义会导致系统错误。另一方面,Parnas 的技术在变化面前是健壮的,在设计换变化的哲学中更合适。
这段话值得逐句读。Brooks 承认的不是一个细节,而是一个方向:让接口的语义保持未知,短期看会增加误解,长期看是唯一能扛住变化的结构。
顺带说,Parnas本人后来对这个问题的表述更硬。他不用"经验证明"这种说法,而是给出一个可以证明的命题:假设有两个模块 A 和 B;如果你可以只依据 B 的接口证明 A 是正确的;那么当你修改 B 而不改接口时,A 不需要任何改动。
这个链条一旦成立,"信息隐藏"就不再是一种风格偏好,而是一个关于变更成本的定理。它也是后面所有关于"服务契约"的数学底子。
七、微服务:把复杂性从空间上搬出去
7.1 复杂性守恒
Michael Feathers 有一句话,我认为是理解微服务最关键的一句:
我坚信软件中存在一条复杂性守恒定律。当我们把大事分解成小块时,我们总是把复杂性推到它们的相互作用上。
这句话解释了为什么微服务既让人兴奋又让人痛苦。
单体架构里,复杂性集中在代码内部:一个类依赖三十个类,一次改动的爆炸半径无法预估。拆成微服务之后,单个服务内部的代码量确实显著下降,很多服务只有几千行——这正是"代码占用面积减少"的说法。但代价同步发生:代码里的函数调用,变成了服务间的网络调用。每个请求的状态必须从一个服务传到另一个服务,才能拼出响应。原来一个栈就能解决的事,现在需要序列化、传输、超时、重试、幂等、补偿。
于是复杂性搬家了。从"代码内部"搬到了"交互之间",从"开发阶段"搬到了"运行阶段",从"程序员的可视范围"搬到了"运维和 SRE 的监控面板"。
7.2 三种复杂性
如果只记住一个区分,记住这个:把软件复杂性分成三层。
类型 | 含义 | 微服务能否降低 |
必备复杂性 | 问题本身固有、无法消除的部分 | 不能 |
表面复杂性 | 实现方式带来的额外纠缠,如杂乱的连线 | 能,且这是主要收益 |
设计复杂度 | 设计不当、重复建设、为预研而引入的复杂性 | 看治理水平,可能反增 |
微服务做的事情,本质上是把"杂乱的连线"收成"一条总线":表面复杂性下降了,必备复杂性一点没变。那些以为上了微服务就能"消除"复杂性的项目,基本都在这条上栽了跟头。
再往前一步,还有一层判断:系统的实际复杂性一定会超过它的必备复杂性,超出的部分就是设计复杂性。设计复杂性本身没有好坏——它可能来自设计不当,也可能来自有意的技术投入(比如做预研)。关键在于,这是一笔投入,你要问清楚它换回了什么。
微服务就是一次复杂性投入。你多花了分布式事务、服务治理、链路追踪、灰度发布的成本,换回来的是独立部署、技术异构、故障隔离和团队自治。这笔账划不划算,取决于业务的变化速度——变化越快,买"独立演进"这个期权就越值。
7.3 债还不掉,只能加速淘汰
还有一个更根本的视角:软件的复杂性总是增加的。
软件像熵,很难掌握,也无法直接测量,而且它遵守热力学第二定律。任何一个长期运行的系统,都会经历这样的过程:很多不同的人在上面工作,每个人都有自己的风格;功能不断被添加、修改、移除;系统还要和越来越多的外部系统集成,长出大量接口。结果是架构越来越不稳定,新功能上线越来越慢,创新被拖住。
所以"微服务能消除技术债"这个说法要打个折。准确的说法是:债是还不掉的。你确定你重构代码、偿还债务的这份工作,本身没有在制造新的债务?存量即债,只要你开动代码生产机器,你就在高筑债台。
微服务真正提供的,是一种加速淘汰的机制。服务粒度小、边界清楚、可以独立部署,意味着单个服务可以被更便宜地重写、替换、丢弃。从宠物变成牲畜,随时可以宰杀。降低单次淘汰的成本,比试图一次性还清债务,要现实得多。
7.4 代价清单
把微服务的收益与代价并列,会更容易做决策:
维度 | 单体 | 微服务 | 净效果 |
单服务代码量 | 大 | 小 | 改善 |
改动爆炸半径 | 大,靠编译期发现 | 小,但错误后移到运行期 | 双向 |
调用成本 | 函数调用,纳秒级 | 网络调用,毫秒级 | 恶化 |
状态一致性 | 本地事务 | 分布式一致性 | 显著恶化 |
故障模式 | 全挂或全活 | 部分失败、级联失败 | 恶化,需新能力 |
独立部署 | 不能 | 能 | 改善 |
组织自治 | 弱 | 强 | 改善 |
可观测性要求 | 低 | 极高 | 新增硬门槛 |
注意最后一行,它不是一个"最好有"的加分项,而是前置条件。
八、组织也是耦合
技术之外还有一层常被低估的复杂性来源:组织本身。
康威定律说,系统的结构会不可避免地复制组织的沟通结构。这条定律在微服务时代几乎是自我实现的:你按团队拆服务,服务边界就会长成组织边界的样子;反过来,如果你先画了一张理想的服务蓝图,却按另一套组织去落地,最终跑起来的架构会向组织妥协。
邓巴数给了组织规模一个生物学的上限:人类能维持稳定社交关系的人数大约在 150 人。超过这个规模,靠"大家都认识"来协调就失效了,必须依赖流程和文档——而流程和文档正是复杂性的新来源。
两个披萨的原则是这条规律在工程上的操作:如果两个披萨喂不饱一个团队,这个团队就太大了。人一多,会议效率下降,与会者倾向于附和而不是表达独立判断,扯皮和推诿随之出现。小团队更容易达成共识,也更容易让"服务边界"和"责任边界"重合。
这三条放在一起,说明一件事:微服务不是纯粹的技术重构,它是组织重构的技术投影。只改代码不改组织,通常会得到"分布式的单体"——服务拆开了,发布还得一起发,数据库还共用一套。
九、把准则落到服务边界上
前面讲的都是判断依据,到底该怎么用呢?Parnas的准则要到服务级别,需要做一次翻译。
9.1 划分前先问四个问题
把"隐藏困难或易变的设计决策"翻译成服务设计语言,可以拆成四个可操作的问题:
问题 | 想验证什么 | 不合格的信号 |
这个边界两侧,变化的原因相同吗? | 是否按变化源切分 | 改一个业务规则,要同时改三个服务 |
这个服务对外暴露的,是契约还是实现? | 是否真的隐藏了决策 | 上游要了解下游的表结构才能工作 |
去掉这个服务,上游还能编译和测试吗? | 依赖是否收敛到接口 | 上游必须起全套环境才能跑单测 |
它挂了,会不会拖着别人一起挂? | 级联风险 | 一个非核心服务超时,主链路雪崩 |
第三问特别值得展开。方案一和方案二最本质的差别,其实就体现在"能不能只凭接口把上游测通"。如果一个服务的存在,使得上游必须启动它、连上它的数据库、造出符合它内部格式的数据才能测试,那么这个边界是假的——你只是把一张大表拆成了若干张互相认识的小表。
9.2 接口只暴露契约
Parnas方案二的接口长这样:CHAR(r,w,c)、WORDS(r)、ITH(i)、SORT()。它们有几个共同特征:
映射到 HTTP / RPC 上,就是几条很朴素的规矩:
反过来,下面这些做法都在把决策重新暴露出去:
9.3 把"互相影响"限流
复杂性的放大器是级联。工程上对付级联的手段已经很成熟,但常常被当成"运维配置"而不是"架构约束":
手段 | 对应的问题 | 注意事项 |
超时 | 无限等待导致的资源堆积 | 超时必须小于上游的超时,逐层收敛 |
重试 + 退避 + 抖动 | 瞬时故障 | 重试会放大流量,必须配合幂等 |
熔断 | 故障服务拖垮调用方 | 半开策略要按业务调,不要抄默认值 |
舱壁隔离 | 单一依赖占满线程池 | 按依赖分组,核心与非核心分开 |
背压 / 限流 | 上游过载传导 | 限流点应靠近入口,且可观测 |
降级 | 非核心能力故障 | 降级路径必须被真实演练过 |
这里有一条容易忽视的原则:每一个跨服务调用,都必须有明确的失败语义。是快速失败、是降级返回、还是排队重试,这个决定必须在设计时做出,而不是等线上出事时由框架的默认值替你决定。默认值往往是最坏的那种:重试三次,每次超时三十秒。
9.4 可观测性不是运维的事
方案二之所以"可理解",是因为一个模块只需要知道它依赖的接口。微服务把这条链路打散了:一个请求穿过七个服务,任何一个人看到的都只是片段。
于是"可理解性"这个准则在分布式系统里必须换一种实现方式——它从"读代码就能懂"变成了"看链路就能懂"。
具体来说,需要三样东西同时成立:
统一的 trace id 贯穿全链路;
每个服务的关键决策点有结构化日志(不是 print("here"));
服务之间的依赖关系可以被自动发现并画出来,而不是靠一份三个月前更新的架构图。
有一句话说得很好:如果没有实时地图显示微服务如何与数据库以及外部服务交互,那么 DevOps 就是盲目的。而盲目的运维,只能靠加人来弥补——这恰恰是《人件》批评过的那种做法。
9.5 反模式清单
反模式 | 表面症状 | 根源的问题 |
分布式单体 | 服务拆了,发布还得一起发 | 边界按组织画,没按变化画 |
共享数据库 | 改表要开五个团队的会 | 数据存储决策没有被隐藏 |
贫血接口 | 上游拿一堆字段自己拼业务逻辑 | 业务决策暴露到了边界之外 |
按技术分层拆服务 | Controller 服务、DAO 服务 | 按处理步骤切,正是方案一 |
按实体拆到最细 | 一个表一个服务 | 只算了拆分收益,没算集成成本 |
无契约演进 | 下游半夜被告知字段改了 | 缺少显式的接口承诺 |
全链路强一致 | 一个下单要协调六个服务 | 把本地事务的思维搬到分布式 |
这些反模式的共同点,都能回到同一句话:它们把"变化的原因"和"部署的单位"搞混了。
十、小结
回到开头的问题:为什么芯片能被控制,软件不能?
因为芯片的每一个部件之间的关系,在流片之前就被穷举过、验证过、写进了设计规则;而软件部件之间的关系,是在几百个人的日常改动中缓慢长出来的,没有人完整地看过那张图。芯片的复杂性是被设计出来的,软件的复杂性是被积累出来的。
这决定了应对方式的不同。前者靠验证,后者只能靠结构。
而结构这件事,1972 年那篇论文已经说得足够清楚了:不要从流程图开始,从"哪些决策是困难的、哪些决策是会变的"开始;让每个模块藏起一组决策;接口只承诺最少的东西。
微服务没有发明新原理,它只是把这条原理的作用范围从函数扩大到了进程——收益被放大,代价也被同比例放大。所以它既不是银弹,也不是骗局,它是一次复杂性交易:用运行期的分布复杂性,换开发期的演进自由度。
这笔交易划不划算,取决于你的业务变化有多快,也取决于你有没有能力把新增的那部分复杂性管住。管不住的时候,分布式系统不会退回单体,它只会变成一个更难归因的单体。
最后留一个问题给自己:每次决定"这里拆一个服务"的时候,你藏起来的是哪一组决策?如果答不上来,那可能只是把一个函数搬到了另一台机器上。
PS,在AI时代,架构的复杂性又是怎样的呢?
【关联阅读】
跳转微信打开