「计算机百年史」系列 · 第 5 篇 / 共 10 篇
按《从铜线到智能——计算机两百年》原书卷次连载。本篇:范式、手艺与协作(1968—2025),共 8 章,约 8.9 万字符。
卷五 · 范式、手艺与协作(1968—2025)卷首语
当代码行数突破个人大脑的处理极限,软件工程就不再是技术问题,而是组织问题。本卷讲述的,是人类为防止大型软件坍塌而发明的全部手艺:用语法禁令替程序员提前支付推理成本(结构化编程),用通用词汇让陌生工程师能结算经验(设计模式),用网络调用的显式代价替代组织沟通的隐性代价(微服务),用四次"搬家"把记忆负担从人脑卸给机器(内存回收)——以及这一切手艺最终汇入的那个新秩序:开源。
必须预先声明:开源运动不是一部"自由战胜封闭"的爽文。从斯托曼对打印机驱动的道德愤怒,到托瓦兹用邮件列表攒出的信誉资本体系,再到云厂商用"网络调用不算分发"绕过 GPL 的白嫖、MongoDB 与 Elastic 的协议叛逃、xz 投毒事件——开源从一场黑客伦理起义,演变成了地缘与商业巨头争夺原材料供应的制度战场。每一章的胜利者,当时都有输掉的充分理由;每一份今天的免费午餐,账单上都写着另一个人的名字。
本卷的主导物理约束有两条,缠绕如双螺旋:超大规模软件系统维护时的人脑认知上限,以及跨组织协作的摩擦成本。前者决定了"一个人一次能把握多少复杂度",后者决定了"一群人一次能对齐多少意图"。结构化编程、设计模式、MVC、并发正确性、内存回收,都是在第一条约束上讨价还价;康威定律、微服务、开源协作模型,都是在第二条约束上建立仪式。本卷的任务,就是把这两本账的原始凭证,一页页摊开。
阅读指引。 本卷是全书"最像管理学"的一卷:工程手艺、组织仪式与开源政治。技术管理者、项目经理与创业者应当全卷精读——每一章都在回答"为什么大型软件会失败,为什么团队会失控"。工程师读者建议精读 049(结构化编程)、050(设计模式)、053(并发正确性)、055(并行代价),跳读 051(MVC,前端向)与 052(康威定律,管理向)。非技术读者建议读 056(开源运动)——它是全书制度叙事的高峰,与 IT 技术细节无关,纯讲人类协作如何从黑客理想主义走向地缘战场。
第 049 章 1968:结构化编程与 goto 之争
加米施,1968 年 10 月
1968 年 10 月 7 日,联邦德国巴伐利亚小镇加米施,约 40 名学者与工业界人士走进会场,参加一场由北约科学委员会(NATO Science Committee)赞助的会议。主席是弗里茨·鲍尔(F. L. Bauer),会议报告后来由彼得·诺尔(Peter Naur)与布莱恩·兰德尔(Brian Randell)整理编辑。会议的标题在当时近乎挑衅——“软件工程”。组织者故意选用“工程”这个词,表达一个愿望:写软件应当成为一门有纪律的、建立在工程原则之上的活动,而不是当时那种全凭个人手艺的即兴劳作。与会者没有辜负这个标题的火药味:整整五天,人们坦率地倾倒各自项目里的烂账——大型软件项目如何普遍延期、如何冲破预算、如何带着严重缺陷交付。这些彼此印证的证词,给一种弥散多年的不安正式定了名:“软件危机”。多年以后,艾兹格·迪杰斯特拉(Edsger Dijkstra)在 1972 年的图灵奖演讲《谦逊的程序员》(The Humble Programmer)中回忆,正是在加米施,软件危机第一次得到官方承认。
阴影有一个具体的名字:OS/360。那是 IBM 在 20 世纪 60 年代为 System/360 系列机器开发的通用操作系统,人类历史上第一次面对如此规模、集成度如此之高的软件工程任务——操作系统本体、多道程序版本、编译器、汇编器、工具程序必须同步开发、协同工作。项目负责人弗雷德·布鲁克斯(Fred Brooks)后来把这段经历写成《人月神话》:向一个已经落后的项目追加程序员,非但没有救火,反而让交付更迟——这就是后来以他名字命名的布鲁克斯定律。加米施会场里坐着的许多人,都在各自的公司里亲历过缩小版的 OS/360:机器越来越快,程序越来越大,而人脑,一次只能装下那么多东西。危机这个词,指的不是某一个项目的失败,而是一种结构性的失配——软件的规模曲线,已经顶穿了人类心智一次能把握的上限。卷五的主导约束,在这间会议室里第一次露出全貌。
“软件工程”这个标题,本身就是一枚投向现状的石子。在此之前,写程序被称作“艺术”“手艺”“黑魔法”,唯独不叫工程——工程意味着图纸、规范、可替换的零件与可追责的流程,而 1968 年的软件业几乎一样也拿不出来。组织者用这个词,描述的不是现实,是战书:要么让写软件配得上“工程”之名,要么承认这个行业是在裸泳。诺尔与兰德尔整理的会议报告,此后成为新学科的开国文献,被引用了半个世纪;次年,人们在罗马又聚了一次,把争论延续下去。但真正让加米施不朽的,并非报告里的任何一条建议,是会议确立的一种话语格式:把失败摆上台面,把“我们搞砸了”变成学科的起点。此后五十年的软件工程史,从能力成熟度模型到敏捷宣言,几乎每一次转向都重复了这个格式——先命名危机,再贩卖药方。
OS/360 的烂账值得多看一眼,因为它是危机最诚实的肉身。布鲁克斯接手时面对的与其说是技术难题,不如说是算术难题:系统越庞大,模块间的接口就越多,每加一个人,沟通链路就多一批,而新人熟悉系统本身又要消耗老人的时间。向落后项目加人,等于向漏水的船上加水手——每个人都要别人腾出手来教他游泳。布鲁克斯后来把这段经历提炼成定律,写进《人月神话》,而定律的残酷之处在于它不提供解法,只提供诊断:人月不能互换,因为软件不是收割小麦,人数与进度之间没有线性关系。加米施会场里的约 40 人,每个人口袋里都装着一个缩小版的 OS/360。他们终于把私下里的抱怨,变成了一门学科的奠基共识。而“软件工程”这个词的命运,本身就是一部微缩的学科史:它从一句战书开始,先变成大学课程目录上的专业名,再变成能力成熟度模型里一摞摞评估表,最后变成今天招聘网站上的职位关键词。从加米施算起,软件业花了半个世纪,才勉强配得上当年那个挑衅性的标题——而且只是在部分领域、部分时间里配得上。命名危机容易,建立工程难;这句1972年迪杰斯特拉在图灵奖演讲里重申的判断,是加米施留给后世最长寿的遗产:危机被正式承认之日,正是艰苦工作开始之时。加米施之后,“危机”这个词在软件业的词典里再也没有离开过——此后每一次范式更迭,都有人宣布新的危机到来,而每一次宣布,都是加米施格式的回声。
而就在这次会议召开前七个月,一封只有一页纸的信,已经把火药撒在了路上。
一封一页纸的信
1968 年 3 月,《美国计算机学会通讯》(Communications of the ACM)刊登了一封短信,标题后来成为计算机史上被模仿最多的句式:《Go To Statement Considered Harmful》。作者是迪杰斯特拉。标题有个少有人知的细节:作者原稿的标题平淡无奇,叫《A Case Against the GO TO Statement》,是刊物的编辑尼克劳斯·维尔特(Niklaus Wirth,后来 Pascal 语言的设计者)把它改成了这个耸人听闻的样子。编辑的这一笔,成就了一个延续几十年的标题模板——后世无数文章竞相仿写,从《某某 Considered Harmful》一路戏仿到《抨击“Considered Harmful”的文章是有害的》。一句编辑部的修辞,意外地为一场技术战争命名。
信的正文只有一页,论证却直指人脑的硬件限制。迪杰斯特拉写道,程序员理解程序的方式,是在头脑里为“进程进展到哪里了”建立一组有意义的坐标:当前执行到文本的哪一行、循环进行到第几次、嵌套深入到第几层。有了这套坐标,静态的程序文本与动态的执行过程才能对应起来,人才能在思维中定位运行时行为正在哪一点,才能断言“执行到这里时,哪些变量已经就绪、哪些事实已经成立”。无约束的 goto 摧毁的正是这套坐标:任何一行代码都可能被来自任何地方的跳转闯入,“这段代码做了什么”取决于所有可能跳进来的地方,程序员被迫在头脑里完整模拟每一条执行路径及其全部状态变化。复杂度不再随代码量线性增长,而是随着跳转的组合爆炸把人淹没。迪杰斯特拉承认一种例外:用于“致命异常”式退出的跳转可以接受;他同时指出,维尔特与托尼·霍尔(Tony Hoare)主张的 case 结构,正是对“多个 if、goto 和标签”这种繁琐写法的更优替代——后来的 switch 语句,就是这条替代路线上结出的果实。
这套坐标论证,在当时有一个并不遥远的镜像:同一个年代的程序员,是真的在纸上画流程图写程序的。框与箭头铺满图纸,goto 就是图纸上纵横交错的线。一个只有几十个框的流程图,画出的跳转线就能乱到无法追踪;这不是比喻,是 1960 年代机房里的日常物理现实。迪杰斯特拉的上千篇手稿(编号从 EWD1 一路排到 EWD1308)里反复出现同一个母题:程序的正确性不能靠调试撞出来,而要从一开始就设计得正确。而“设计得正确”的前提,是人能把握自己写下的东西。一页纸的信,论证的从来无关美学,它是一桩认知能力的破产清算。
写信的人值得先认识一下。迪杰斯特拉 1930 年生于荷兰鹿特丹,1972 年凭在程序设计语言与方法学上的开创性工作获得图灵奖。他的写作载体本身就很说明问题:职业生涯里写下上千篇手稿,按 EWD1、EWD2一路编号,内容从算法、语义学漫游到对行业的辛辣评论——一位把思考本身当成发表的学者。ALGOL 是他的母语环境:1960 年问世的 ALGOL 60 是第一种真正意义上的结构化雏形语言,却保留着 goto 语句,原始报告的第二个示例程序里就躺着四个跳转,标签起名 AA、BB、CC、DD,透着一股“能跳就行”的草莽气。迪杰斯特拉对 goto 的怀疑,早在 1959 年哥本哈根 ALGOL 会议前的一次讨论里就被海因茨·泽马内克(Heinz Zemanek)点破过——泽马内克当场质疑,跳转凭什么与赋值享有同等语法地位。迪杰斯特拉后来承认,怪自己当时没从这句话里得出结论。
最早把怀疑变成文字的另有其人:会议报告的编辑诺尔。诺尔发现,回跳的 goto 常常是“伪装的 for 语句”——把 for 子句写回它本该在的位置,算法立刻变清晰;他还主张,教 ALGOL 就别再画流程图了,流程图弊大于利。1965 年,迪杰斯特拉记录了两位素不相识的部门经理不约而同的观察:程序员的质量,与其程序里 goto 的密度成反比;他自己动手把若干程序改写成无 goto 版,结果后者更短、更清晰,尽管改写过程“很费劲——我们太熟悉跳转指令了,忘掉它需要用力”。同一年,彼得·兰丁(Peter Landin)把这种改写称作一种“游戏”:把程序里显式排序的信息压缩掉,赢来的常常是更透明的程序——更容易懂、更容易改、更容易嵌入更大的系统。一页纸的信发表前,弹药早已堆满了仓库,缺的只是一个扣扳机的人。维尔特改标题的那一笔,就是扳机。
信发表后的最初几年,回声寥寥。真正的担保来自数学——两年前发表的一篇论文,被结构化编程的拥护者们抬出来,当作定理级别的尚方宝剑。
数学的担保
担保的文本是 1966 年发表在《美国计算机学会通讯》上的一篇论文,作者是两位意大利数学家:科拉多·伯姆(Corrado Böhm)与朱塞佩·贾可皮尼(Giuseppe Jacopini)。结论干净得像一句口号:任何流程图,都可以只用三种控制结构重写——顺序(做完一件再做下一件)、选择(按布尔值二选一执行)、循环(按布尔值为真重复执行)。这就是后来所称的伯姆—贾可皮尼定理,又名结构化程序定理。它的根子更早:1964 年,伯姆先定义了一种极简的图灵完备语言 P′′,证明仅凭顺序加迭代就能计算任何可计算函数;1966 年的论文把“存在某种写法”推进为“任何现有流程图都能被改写”。对 1968 年的论战双方来说,这篇论文的价值不在于细节,而在于姿态:数学证明了 goto 在逻辑上是多余的,一切跳转能表达的东西,三结构全能表达。反 goto 阵营从此有了一句简报级别的口号:连数学都站在我们这边。
口号的源头比口号本身更有趣。伯姆 1964 年的工作抛开流程图,从零造了一门语言:P′′。这门语言极简到只有几条指令,专门用来描述一族图灵机,顺带证明了一件事——表达能力不需要跳转来凑数。它极简的血统后来开枝散叶,启发了以“难用”为行为艺术的 Brainfuck——极简主义这条线索,从数学证明一路通向了极客亚文化,这是伯姆当年无论如何想不到的。而在论文的另一头,还有一条更早的、来自工程现场的线索:1960 年夏天,加州大学洛杉矶分校的 D. V. 肖尔(D. V. Schorre)开始用缩进大纲写程序,以缩进表示控制流,彻底抛弃流程图。他把旧式流程图讥为“气球图”——线条臃肿、框框相连,像一串气球。克努特 1963 年听说了这套激进做法,第一反应是不信;1964 年,他拿八皇后问题当考题挑战肖尔,肖尔用递归加布尔变量应战成功。缩进即结构,这个后来被 Python 写进词法分析器的主意,最早是 1960 年一位工程师的私人习惯。定理、语言、大纲,三条线索在 1966 年前后交汇,织成同一句话:控制流可以被驯服。
但这句口头禅,恰恰建立在对论文的误读之上。1980 年,戴维·哈雷尔(David Harel)梳理了截至当年的大批文献,给出一句刻薄的考据:伯姆—贾可皮尼的原文“被引用的次数远多于被细读的次数”。技术圈里实际流传的,是一个民间定理版本:用一个全局 while 循环加一个程序计数器变量,逐个模拟原流程图的每一个框——计数器走到几,就执行第几个框,做完更新计数器,循环往复。这个构造确实只用了三结构,也确实等价,但它把原程序的结构丢得一干二净:读代码的人看到的不再是业务逻辑,而是一台用高级语言手搓的冯·诺依曼机,程序计数器在几十个分支之间来回横跳。布鲁斯·米尔斯(Bruce Ian Mills)后来的讽刺一针见血:在块结构语言里模拟冯·诺依曼机,能复刻任何意大利面条的行为,但它依然是意大利面条。唐纳德·克努特(Donald Knuth)更早指出了同一件事:这种机械变换之后,原程序的结构信息完全丢失,变换后的版本不见得比变换前更清晰。定理的英文维基条目今天仍保留着一句诚实的判语:伯姆—贾可皮尼的构造,更可能遮蔽程序而非改进程序。它没有终结争论,恰恰相反,它标志着争论的开始——迪杰斯特拉的信,就发表在论文刊出两年之后。
这里藏着本章最值得停留的一层反讽。拥护者们举起数学担保,论证“goto 无用”;而数学担保的真实内容是“goto 可被机械改写”,改写结果可能是更糟的代码。从“逻辑上多余”到“工程上不该用”,中间隔着一道数学从未跨过的鸿沟:人读代码的成本。定理证明的是表达能力的等价,迪杰斯特拉论证的是认知成本的差异——前者是关于机器能算什么,后者是关于人能懂什么。把前者当成后者的证据,是论战史上最成功的一次偷换,也是最诚实的一次巧合:双方吵的从来不是同一件事,却在同一个词上达成了和解。
机械改写还有一笔具体的技术欠账,名字叫“一个半循环”(loop-and-a-half)。许多搜索类问题天然长成“先读一次,再判断要不要继续”的形状,硬套纯三结构,就要在循环前后复制半截代码,或者引入额外的布尔标记变量——为了消灭一个跳转,凭空多出一批状态。Pascal 恰好被这两笔欠账同时击中:新结构引入的辅助变量、为单出口复制的代码,让初学者叫苦不迭。支持自动化的务实派很快动手:1971 年,阿什克罗夫特(Edward Ashcroft)与马纳(Zohar Manna)最早提出了把非结构程序自动改写成结构形式的方案之一——既然人不擅长机械改写,就让机器干。但 1970 年代还有哲学层面的反对,爱德华·约登(Edward Yourdon)记述过这种声音:必须从一开始就用结构化方式思考,事后改写是作弊。务实派的回答同样干脆:现存的上百万行老代码等不起思想改造,能自动规整一行是一行。这场“改写派 vs 重写派”的小争论,是后来全部重构工具与代码异味理论的预演:机器替人承担机械劳动,人把精力留给真正的设计。
而和解的另一方,很快派出了全场分量最重的辩手。
约束决斗:克努特的保留意见
1974 年 12 月,克努特在《ACM 计算综述》(ACM Computing Surveys)发表长文《Structured Programming with go to Statements》。标题本身就是一记回马枪:结构化编程,配 goto 语句。他的立场后来被浓缩成一句口号:goto 不是错,乱用才是错。但口号遮蔽了这篇论文真正的成色——它值得按 41 页的原貌细读。论文刊于《ACM 计算综述》1974 年 12 月号,从 261 页绵延到 301 页,开篇先摆三句题词:一句米莱的诗(“你走你的路,我留守原地”),一句鲍勃·迪伦的歌名(“你走你的阳关道,我过我的独木桥”),一则止泻药广告(“你是否正遭受消除之痛?”)——三句都扣着“走”与“消除”,作者用幽默先给论战降温:这不是圣战,是一次会诊。克努特在引言里坦白,标题主要是为了博眼球;真正的主张写在摘要里:某些情况消灭 goto,另一些情况引入 goto,两边各有道理。
论文里埋着全场最有杀伤力的一段引文,出自迪杰斯特拉本人。据克努特转引,迪杰斯特拉私下写道:千万别以为我对 goto 抱着教条,“别人把它变成了一门宗教,好像编程的概念难题能靠一招编码纪律解决似的。”判了 goto 死刑的人,亲口否认自己是判官。这个细节的分量在于:连发起者都承认,禁令一旦变成宗教,就从工具变成了图腾。克努特紧接着把类比推向数学史:1904 年罗素悖论动摇古典推理,直觉主义者布劳威尔主张扔掉排中律,希尔伯特大怒——禁止数学家用排中律,如同禁止天文学家用望远镜、禁止拳击手用拳头。在克努特的映射里,goto 就是程序员的排中律:古典工具里“最珍贵的宝贝”之一,围剿它的人是在“把麻烦的东西扔下船来拯救数学”。他预言结局会与数学史相同:纯粹派指路,他人把古典工具洗净后安全使用——双方都会赢下一半。
论文还留下两个值得收入史册的细节。其一是 1971 年国际信息处理联合会(IFIP)大会上的插曲:克努特结识了日本学者后藤英一(Eiichi Goto)博士,后者风趣地抱怨“人们总是在消灭我”——Goto 与 goto 同音,一个姓氏成了论战的双关。其二是克努特的预言:他梦想 1984 年出现一门凝聚共识的好语言(或语族),戏称为乌托邦 84(UTOPIA 84),并追问这门新语言(他戏称为 NEWSPEAK)里还会不会有 goto。今天回看,这个预言落空了——1984 年没有共识语言,1994 年也没有。语言没有收敛,争论却收敛了:人们不再追问 goto 该不该存在,转而追问每一种跳转的落点是否可见。这是反辉格的一课:预言家猜中了问题的消失,没猜中答案的形状。克努特逐一检视了若干真实程序模式:在某些搜索与扫描场景里,一次恰到好处的向前跳转,比层层嵌套的布尔标记变量更清晰,也更快;在资源受限的环境里,为照顾所谓纯粹性而引入的辅助变量与重复代码,是用运行时代价为审美买单。他甚至把矛头指向民间定理式的机械改写:把goto 全部消掉之后 if 套 while 的洋葱代码,恰恰是迪杰斯特拉最痛恨的不可读——以结构化之名,行意大利面条之实。
这个反对意见满足约束决斗的硬性标准:它在当时占据技术道德高地,且完全言之成理。克努特不是无名之辈,他是《计算机程序设计艺术》的作者,是逐字逐句抠过算法的人;他的论证方式不是“传统不容玷污”,标准是“拿出代码来比”。更关键的是,他的批评与迪杰斯特拉的坐标论证并不在同一层面开火:迪杰斯特拉说的是“无约束跳转摧毁推理坐标”,克努特谈的是“受约束跳转保留局部清晰”。一个谈的是任意跳转的灾难,一个谈的是特定模式的收益——两人各自正确,战场却被划在了同一个词上。克努特论文的另一半贡献,是一套“先写对、再写快”的方法论:先写出可读、正确、可能低效的版本,确认逻辑无误后,再系统地变换成高效、正确、可能难读的版本。优化是第二步的事,第一步必须让人看懂。这套方法论后来长成一句行业格言的源头——过早优化是万恶之源——而它针对的正是当时的流行病:为了快,人人把代码写成只有自己当下能懂的密文,三个月后连自己都看不懂。克努特还预先写下了警告:如果哪天人们发现结构优美的程序只跑出脏程序一半的速度,别去怪结构,要去查编译器实现布尔变量与过程调用的系统开销。性能的账,要记在实现者头上,不要记在纪律头上。这句话在随后二十年里反复应验:每一次“结构化太慢”的抱怨,最后几乎都被更聪明的编译器平息,而不是被放宽的纪律。后世转述者喜欢把这场争论讲成圣战,1999 年的一场演讲甚至宣称支持 goto 的人“已经被埋得很深”,当代辩护只剩“从深层嵌套里跳出来”这类极弱的论点。这种盖棺论定恰恰反衬出 1974 年的现场有多胶着:需要出动克努特这个级别的人物写长文,才能为 goto 守住最后几寸阵地。
纯粹派把战线推得更远。既然定理证明三结构足够,那么连循环中途的 break、从函数中部直接 return,都成了“证明里用不到”的坏实践——一切循环都该只有一个出口。Pascal 语言(1968—1969 年间设计,维尔特本人的作品)把这套单出口哲学铸进了语法,一度成为高校入门教学的首选。但教学现场很快交出了罚单:被转引的一项 1980 年研究发现,只允许用 Pascal 提供的纯结构写数组查找,答对的受试者只有两成;而允许中途 return 的版本,无人写错。数字的口径或可商榷,方向却难以否认——当纯粹性要求人用违反直觉的方式思考,认知税就从 goto 身上转移到了三结构本身。迪杰斯特拉想为人脑减负,纯粹派却为人脑加了另一种负。约束的两端,就这样在胜利前夜悄悄调了包。
胜负在 20 世纪 70 年代末其实已经分晓:新语言纷纷砍掉或雪藏 goto,教科书统一口径,结构化编程成为默认常识。但胜利的形状,值得细看——赢的不是“消灭跳转”,而是“规训跳转”。
被驯化的跳转
今天的程序员活在一个 goto 无处不在又无处可寻的世界里。循环里的 break 和 continue,就是被限制了落点的跳转:只能跳到当层循环的出口或下一轮,不许跨函数乱飞。异常处理是跨层跳转:错误沿着调用栈一路抛回预设的捕获点,落点由语法结构事先钉死。Go 语言的 defer、Java 的 finally,是“保证执行的跳转”:无论正常返回还是异常炸开,收尾代码必定执行。甚至函数返回本身,就是一次跳转。每一种,都是当年被判死刑的 goto 的嫡系后代,只是全部戴上了镣铐:落点可见、方向受限、与块结构绑定。迪杰斯特拉当年点名豁免的“异常退出”,后来长成了整套异常机制;他当年要求的那组“语义坐标”,今天由块结构、调用栈与异常表共同维持。历史没有处决 goto,历史把它收编了——收编的条件,正是迪杰斯特拉开出的那张坐标清单。这张清单的每一项,后来都长成了语言里的固定建制:case 结构长成 switch 语句,1960 年代末随 Pascal 定型;受限的向前跳出长成 break 与 continue,成为循环的标配;“异常退出”的豁免口长成整套异常处理机制,调用栈、异常表与 finally 块共同保证:无论跳得多远,落点永远可查、资源永远可收。收编史的另一面是教学史:Pascal 带着单出口哲学统治高校课堂直到 1990 年代中期,一代程序员的第一课就是“goto 不存在”。等到这代人成为主力,争论在事实上已经结束——不是被说服的,是被毕业的。毕业是最彻底的胜利:不需要反驳反对者,只需要等教科书翻页。
唯一拒绝收编的地方,是 C 语言的领地。Linux 内核是纯 C 写成的:没有异常、没有 RAII、没有析构函数。设备初始化的典型流程是分步申请资源——申请 A,再申请 B,再申请 C;任何一步失败,必须把之前已成功申请的资源严格逆序释放,漏掉一步就是泄漏乃至崩溃。用纯结构写,释放逻辑随资源数量层层嵌套;用 goto 写,释放清单摊平成一张表:
深嵌套:每加一种资源,多一层 goto 扁平化:标签即释放清单
if (alloc_A() < 0) if (alloc_A() < 0) goto out;
return -ENOMEM; if (alloc_B() < 0) goto err_free_A;
if (alloc_B() < 0) { if (alloc_C() < 0) goto err_free_B;
free_A(); /* 干活 */
return -ENOMEM; free_C();
} err_free_B: free_B();
if (alloc_C() < 0) { err_free_A: free_A();
free_B(); out: return ret;
free_A();
return -ENOMEM;
}
左边每新增一种资源就要改动多处,右边新增资源只加一行申请加一行释放。内核社区的选择无关怀旧,纯粹是算账:在没有语言级兜底机制的领地里,受约束的向前 goto,是认知成本最低的写法。goto 在这里活得很好,因为这里的约束——纯 C、无异常——恰好是 1968 年的约束。时间在这个角落里停住了。
int init_dev(void)
{
int ret = 0;
if (alloc_A() < 0) { ret = -ENOMEM; goto out; }
if (alloc_B() < 0) { ret = -EIO; goto err_free_A; }
if (alloc_C() < 0) { ret = -EIO; goto err_free_B; }
/* 正常核心业务逻辑 */
free_C();
err_free_B: free_B();
err_free_A: free_A();
out: return ret;
}
豁免区是有边界的,边界本身就是一张坐标清单的民间版。内核里的 goto 只允许向前跳,不许回头——回头会形成循环,而循环必须用循环语句写,这条没有例外;标签按释放顺序命名,err_free_B 下面一定是释放 B 的代码,读代码的人看到标签就知道自己身在释放链的哪一环;标签只出现在函数尾部的释放区,业务逻辑区里见不到跳转。这三条不成文的规矩,恰好是迪杰斯特拉坐标系的工程翻译:落点可见(标签即路标)、方向受限(只向前)、与块结构绑定(尾部释放区)。内核黑客没有读过 1968 年的信,却用代码规范重新发明了信里的结论。约束在这里换了一种存在方式:不是编译器禁掉的,是社区用眼睛与审查禁掉的。审查者看到回跳的 goto 会打回补丁,看到标签乱命名会要求重写——人肉编译器,执行的是同一套语义。1968 年的禁令以语法形式管住了应用层,以规范形式管住了内核层,管住的都是同一件事:跳转必须携带落点坐标。
从加米施的会议室回望,这场战争打了六年(1968—1974),余波拖了十年,结局是三方各取所需:教科书拿到了三结构的纪律,工程师拿到了 break 与异常的便利,内核黑客留下了 goto 的豁免区。没有一方全胜,也没有一方全错。
所以,本章的判断是:结构化编程的胜利,不是一场正确对错误的审判,而是一次人类为自己心智上限立法的过程——当软件的规模曲线顶穿人脑一次能把握的复杂度,行业就用语法禁令替每一个程序员提前支付了推理成本;goto 没有死,它只是被收编成所有跳转都必须携带落点坐标的样子。有人可以反驳:如果未来的证明工具与 AI 结对编程能替人承担坐标系的维持,禁令的根基就会动摇——这正是 Linux 内核角落里时间停住给出的提示:约束松动的每一种写法,至今仍在为“人得看懂”这条底线缴税;只要读代码的还是人,1968 年的那张坐标清单就依然有效。
第 050 章 1994:设计模式与通用工程词汇的固化
当 simple factory 不再 simple
21 世纪初的某间企业软件公司里,新人接到的第一个任务,是给订单系统加一种支付方式。mentor 指着代码仓库说:先看 PaymentStrategy,再看 PaymentFactory,最后到 ApplicationContext 里确认注入关系。新人花了三天画出一张类图:接口 4 个,实现 12 个,工厂 3 个,配置 200 行——为了加一个“用新渠道付钱”的功能。mentor 看了一眼类图,点了两个类说“这俩能合并”,又圈出一个接口说“这个抽象没人会扩展,先留着,以后有人扩展你就立功了”。新人在笔记本上记下第一条职场经验:在这里,代码的复杂度不是成本,是能见度——类越多,工作量越显得实在。模式在这里第一次露出它的另一张脸:评价标准。标准一旦确立,达标本身就成了目的。老员工安慰他:这还算克制的,隔壁项目组上个月把一个查数据库的服务拆出了三十个类,单例套工厂,工厂套代理, review 时没人敢说删一句,因为每个类头顶都贴着设计模式的名字,删哪个都像在否定前人的架构智慧。类爆炸到这种程度,争论的焦点早已不是代码对不对,而是谁有资格说“这过度了”。词汇在这里完成了异化:它本是用来谈论设计的普通话,变成了证明资历的文言文。新人不敢质疑,不是因为代码无懈可击,是因为质疑一个“工厂”需要先证明自己懂工厂——话语权被词汇本身没收了。亚历山大当年把模式交给住户,是为了让住户能跟建筑师讨价还价;三十年后,住户拿着模式砌起更高的墙,建筑师反而成了需要仰视的祭司。同一套工具,在建筑界下放权力,在软件界集中权力——工具不决定政治,稀缺决定政治:当读懂代码的人是少数,词汇就从桥梁变成关卡。
这不是段子,是 1990 年代末到 2010 年代企业级 Java 世界的日常生态。一个只查数据库的服务,被单例加工厂加策略加模板加装饰器层层包裹,类从 3 个膨胀到 30 个,复杂度翻了十倍,扩展性毫无长进——社区后来把这种症状叫做锤子综合症:如果手里只有一把锤子,看什么都像钉子。讽刺的是,发明这套词汇的人,最初想解决的恰恰是沟通成本;而词汇一旦成为资历的徽章,沟通就异化成了表演。设计模式的故事,就是一部“人类为了降低协作成本而发明黑话,黑话反过来统治人类”的寓言。要讲清它,得从一位建筑师说起。
建筑师的语言
克里斯托弗·亚历山大(Christopher Alexander)本来要解决的,是 20 世纪 60 年代建筑学的危机:现代主义批量生产的楼房越盖越多,住在里面的人却越来越觉得不对劲。1964 年,他出版《形式综合论》,提出形式因背景而生——建筑的问题要用集合与图论分析,甚至动用了 IBM 大型机跑程序;但算着算着他发现,变量多到一定程度,数学模型反而抓不住重点,结构复杂到只能转向更具生成能力的表达方式。1966 年,他发表《城市并非树形》,指出活的城市是半网络结构,而不是树状的功能分区:树形是规划师在图纸上自上而下画出来的——居住区、商业区、工业区彼此分离,像一棵整齐的树;半网络是城市自然生长的样子——一个街角同时是交通节点、社交场所与小买卖的摊位,重叠、交叉、互借。规划师的树整齐但没人气,生活的网混乱但好用。这个判断后来成为模式思想的地基:好的结构不是分解出来的,是生长出来的;设计者的任务从此改写:不再画一棵完美的树,改成培育一张能自我修补的网。软件业花了二十年才听懂这句话:模块依赖图里,树状的层层调用看着干净,一旦顶层变化整棵树跟着抖;网状的事件驱动看着乱,单个节点倒下不影响全局。从分层架构到微服务的摆动,本质上是同一场“树还是网”的争论换了场地。亚历山大在 1966 年写下的,不只是城市理论,是所有复杂系统组织的通用判据。
1967 年之后,他带着团队在伯克利的社区里检验理论,一砖一瓦地试错,路子越走越像人类学家。而 1975 年的《俄勒冈实验》把“权力重新分配”推到了极致:大学校园的规划不再由建筑师一次性画完,而是定出几条大模式,师生拿着模式自己决定每一栋楼的位置与形状,边建边改。住户从图纸的观众变成建造的参与者——这在 1970 年代的建筑界是离经叛道,在今天的软件业却是常识:敏捷开发里用户故事的优先级排序,开源社区里 issue 投票决定路线图,都是俄勒冈实验的远亲。亚历山大相信,好建筑有一种“无名品质”,说不清、但住进去的人都认得;模式语言保证不了杰作,它是让普通人也能参与建造的脚手架。“无名”二字是整套理论的诚实之处:他承认,好坏的最终标准不在图纸里,在居住者的身体里——阳光照不照得到早餐桌,风穿不穿得过走廊,孩子找不找得到捉迷藏的角落。软件业借走模式时,借走了格式,弄丢了“无名”:代码好坏的标准被简化成“用了几个模式”,居住者的身体感受——读代码的人舒不舒服——反而没人问了。企业级 Java 的类爆炸,根子上是这次弄丢:当评价标准从“人”变成“模式”,模式就从脚手架变成高跟鞋,看着体面,走路崴脚。建筑师不再是图纸的独裁者,住户可以拿着模式跟建筑师讨价还价——“这里要用那个晒太阳的窗台模式”。权力被语言重新分配了,这才是模式最锋利的政治含义。
这套思想传到软件界,走了一条意外的路。1987 年,肯特·贝克(Kent Beck)与沃德·坎宁安(Ward Cunningham)把模式用于 Smalltalk 图形界面的生成,在 OOPSLA 会议上发表,却没激起水花——软件界当时正忙着争论语言与方法论,没空理会建筑师的隐喻。Smalltalk 是最需要模式的语言,也是最不需要模式书的语言:它的图像界面本就由一套活的对象协作网构成,贝克与坎宁安只是给既有的实践起了名字。名字起了,听众没来——时机比正确更重要,这是模式运动的第一课。转机在 1990 年代初:软件工程界开始零星研讨模式话题,一次次小会开下来,共识慢慢成形——软件业缺的不再是语言特性,是一套能说清“我们正在用什么结构”的通用词汇。加米施会议过去二十多年,软件规模又翻了几番,人脑的上限还是那个上限;这一次,人们决定从建筑师手里借工具。
借工具的人,是四位工程师。
二十三种名字
1994 年,埃里希·伽马(Erich Gamma)、理查德·赫尔姆(Richard Helm)、拉尔夫·约翰逊(Ralph Johnson)、约翰·威利赛迪斯(John Vlissides)联名出版《Design Patterns:可复用面向对象软件的元素》。时机耐人寻味:C++ 正在统治企业开发,面向对象从学术时髦变成工业现实,满世界都是现学现卖的类层次——复用喊得震天响,复用的代码没几行。行业缺的不是“写类”的能力,是“写出能被别人复用的类”的能力。四人的书恰好回答了这个问题:复用的单位不是代码行,是结构;结构要复用,先得有名。23 个名字,就是 23 种被验证过“值得复用”的结构。四人后来被尊称为“四人帮”(Gang of Four,GoF)。书很薄,野心很大:把这些解法按用途分成三类:
创建型(5):单例 工厂方法 抽象工厂 建造者 原型
结构型(7):适配器 装饰器 代理 外观 桥接 组合 享元
行为型(11):策略 观察者 命令 状态 模板方法 迭代器
中介者 备忘录 解释器 职责链 访问者
每个模式的写法都是固定格式:名字、意图、适用场景、结构、后果——像词典词条。这套格式本身就是一门方法论:意图回答“它解决什么”,场景回答“什么时候别用它”,结构给出类图骨架,后果诚实列出代价——包括它引入的新问题。一个不敢写“别用我”的模式,不是模式,是广告。GoF 书里每个模式都附着“相关模式”索引,23 个词条互相勾连,翻开一页能顺藤摸瓜找到另一页——这正是亚历山大“模式嵌模式”的软件翻版。它的革命性不在代码,而在名字。在此之前,程序员之间描述设计只能靠比划:“就是那个,你把算法抽出来,传进去,运行时换的那个东西。”在此之后,一句话就够了:“这里用策略模式。”接手项目的人看到“策略”两个字,立刻知道这里有多套可替换的算法,新增一种不用改老代码。词汇把协作成本压了下去:code review 时争的从“这坨代码什么意思”变成“这里该不该用策略”,争论的层级上升了一层。新词很快长出社会生命:招聘启事开始写“熟悉常用设计模式”,面试题开始考“手写单例”,培训班把 23 个名字做成脑图。词汇从工具变成硬通货——流通越广,面值越硬;直到有一天,不会背这 23 个名字的人,在面试里先矮三分。词典的下一页,写的是异化。但那是后话,先把兵点完。这正是卷五主导约束的正面战场——当系统规模超出个人大脑,统一词汇就是跨人协作的脚手架。
23 个名字各有各的来头,值得点一遍兵。创建型管“对象怎么生”:单例管唯一,工厂方法管“子类决定造谁”,抽象工厂管“一次造一整套配套产品”(比如跨平台界面库,Windows 风格与 macOS 风格各来一套按钮加窗口),建造者管“步骤繁多的组装”(点餐时主食加配菜加饮品,一步步攒出一单),原型管“照着现成的克隆”。结构型管“类与对象怎么拼”:适配器给老接口包一层新皮,装饰器一层层往上加功能(Java 的输入输出流就是层层包裹的教科书),代理替本体把门(远程代理、权限代理、AOP 织入的那些切面),外观给一堆子系统留一个前台,桥接把抽象与实现拆成两棵树各自生长,组合让“单个与一群”共用一个接口(文件与文件夹都能被打开),享元把细粒度对象池化共享。行为型管“对象之间怎么谈”:观察者是一对多的广播,命令把请求包成对象(排队、撤销、日志都靠它),状态机把“处境”本身对象化,模板方法定骨架留钩子,迭代器把遍历从集合里抽出来,中介者让一群对象只跟中间人说话,备忘录给后悔药留快照,职责链把请求往下传直到有人接。点兵完毕会发现一个规律:创建型在跟“new”较劲,结构型在跟“接口不合”较劲,行为型在跟“if-else 地狱”较劲——每一个模式背后,都是一类让 1990 年代程序员夜不能寐的具体痛苦。
策略模式是理解这套词汇最好的标本。需求是订单系统支持多种支付,初版写法是 if-else 地狱:
public void pay(String channel) {
if ("alipay".equals(channel)) {
// 20 行支付宝逻辑
} else if ("wechat".equals(channel)) {
// 30 行微信逻辑
} // 加一种渠道,就要改这个方法
}
每加一个分支都要动老代码,测试要把全部分支重跑一遍。策略模式的改法是把每种算法抽成独立类,共用一个接口,调用方只认接口:
interface PayStrategy { void pay(Order o); }
class AlipayStrategy implements PayStrategy {
public void pay(Order o) { /* 支付宝逻辑 */ }
}
class PayContext {
private PayStrategy s;
PayContext(PayStrategy s) { this.s = s; }
void checkout(Order o) { s.pay(o); }
}
加新渠道时,老代码一个字不动,只新增一个类。扩展性从“改”变成了“加”——这就是开闭原则的肉身。观察者是另一个高频标本:新闻发布系统里,发布者维护一张订阅者名单,一有更新逐个通知;不用模式的写法是发布者逐个调用各模块的更新函数,加一个订阅者就要改发布者。新人入场常犯的错是把通知逻辑写进观察者,把观察者养成上帝类——发布与订阅的边界一旦模糊,广播就退化成纠缠。命令模式则把“请求”本身对象化:排队、记日志、做撤销,都靠“请求是对象”这个前提撑着;文本编辑器的每一次击键,背后都是一个可撤销的命令对象。迭代器更安静:它把“怎么逛”从集合里抽出来,逛列表、逛树、逛哈希表用同一套姿势,调用方甚至不知道自己在逛什么——今天所有语言的 for-each 循环,都是迭代器被语言收编后的样子。备忘录管后悔药:编辑器的撤销、游戏的存档,都是把状态快照压进栈里,需要时弹出来;访问者管“给一堆类批量加新活”:想给所有图形加“导出”功能,又不想改每个类的代码,就请访问者上门服务。模板方法则定下骨架、留出钩子:父类规定步骤,子类只填空,框架与应用的分工就这么划定了,Web 框架的请求处理流水线全是这个形状。23 个模式里,一大半都是这种“把变化点封装起来”的变形:工厂封装“创建谁”,观察者封装“谁通知谁”,状态封装“当前处境”。读完这本书的工程师,等于集体购买了一套压缩过的经验:前人踩过的坑,后人用名字绕行。
但名字也是咒语。当“策略”“工厂”“单例”成为资历徽章,第一节的类爆炸就不可避免了。更重要的是,一个尖锐的问题始终没有回答:这些模式里,有多少是真智慧,有多少只是语言缺陷的绷带?
补丁论
1996 年 5 月 5 日,彼得·诺维格(Peter Norvig)在 Object World 大会上发表演讲《Design Patterns in Dynamic Programming》,把桌子掀了。他的论证简单粗暴:把 23 个模式逐个拿到 Lisp 与 Dylan 这类动态语言里检验,结果 16 个被语言自带的能力简化或直接消除。比如工厂模式要解决的“运行时决定创建哪个类”,在“一等函数+动态类型”的语言里常常只是一次函数调用;许多需要类层层包裹才能表达的结构,用闭包几行就写完。诺维格把模式按“语言实现层级”分档:最低一档叫“不可见”——语言本身就是答案,你甚至意识不到那里曾经有个问题,比如类实例化吃掉了早年的对象创建模式;中间一档是非正式的惯用法,程序员口口相传但不必写成类;最高一档才需要正式的模式实现。23 个模式过筛之后,16 个掉进前两档——在 Lisp 与 Dylan 里,它们要么是语言自带,要么是几行惯用法。诺维格把模式按“语言实现层级”分档的潜台词是:模式的名单不是永恒的,它随语言的水位涨落;今天的正式模式,是明天的语言特性,是后天的常识。结论像一句判词:模式不是智慧的结晶,是语言缺陷的补丁;换一门表达力更强的语言,一大半模式当场失业。
本卷前文恰好藏着一个现成的证据:Python 的 sorted 函数接受 key 参数,调用者传一个函数,排序规则随传随换——这正是策略模式的幽灵:行为被参数化、调用方只认接口。但在 Python 里,它甚至不配拥有一个模式的名字,就是一次普通函数调用。一等函数吃掉策略,动态类型吃掉工厂,垃圾回收吃掉大量资源管理模式——语言每进化一次,GoF 的名单就短一截。1990 年代的 Java 程序员为策略模式写四个类,Python 程序员传一个 lambda;两个人解决的是同一个问题,付出的仪式成本差了一个数量级。后来主流语言纷纷把“函数当参数传”变成标配,策略与命令的样板代码成片倒下——不是模式错了,是水位涨了,礁石就该露出水面再沉下去。补丁论最有力的证据,从来不是论文里的统计数字,是这种跨语言的日常体感:你上一次亲手写一个策略类,是什么时候?这场水位上涨在二十年后还有续集:Go 语言干脆把继承与泛型请出门,工厂与抽象工厂在它那里连出场机会都没有——不是被更好地实现了,是被问题本身的消失而失业;而 Rust 的所有权机制则把“谁创建谁释放”的整本账从运行时搬进编译器,单例与对象池那一章的仪式成本,被借用检查器提前报销。两门后起语言,一个做减法,一个做证明,补的恰好是 GoF 名单里最厚的那几页。
这个指控的分量,在于它有第二证据。哈纳曼(Hannemann)与格雷戈尔·基斯莱斯(Gregor Kiczales)用面向方面编程语言重写 23 个模式,发现 17 个的代码级依赖凭空消失——切面机制把散落在各处的胶水代码收拢之后,模式要解决的问题有一大半不复存在。切面吃掉的是另一种东西:横切关注点(日志、安全、事务),这些在面向对象里必须靠模式手工编织的经纬,在切面语言里是原生语法。两份独立的研究,指向同一个伤口:GoF 模式诞生于 C++ 的语境,带着静态类型、单继承、无一等函数的全部胎记。工厂模式是在给“不能把类当参数传”的语言打补丁,策略模式是在给“没有一等函数”的语言打补丁,模板方法是在给“缺少闭包”的语言打补丁。把胎记当成美学,是 1990 年代软件业最大的集体幻觉。
但补丁论也有打不到的地方,而打不到的地方,恰恰是模式真正的价值。诺维格消灭的是代码实现,不是沟通词汇——就算策略模式在 Lisp 里只是一行函数调用,工程师在 review 时仍然会说“这里是个策略”,听的人立刻懂。词汇一旦进入共同体,就不再依附于任何一门语言;它活在人的嘴里,不活在编译器里。亚历山大的原意从来不是“代码复用”,而是“让人能谈论设计”——住户拿着模式跟建筑师讨价还价,靠的是名字,不是图纸。GoF 的书名副其实:元素的真正含义,是“谈论设计的通用词汇表”。补丁会过时,词汇长青:语言进化吃掉实现,留下了名字。这是约束决斗里双方各自正确的那条分界线——诺维格谈的是代码,GoF 谈的是协作;前者是对的,后者同样是对的。
分界线划定之后,真正的问题才浮出水面:词汇长青,但词汇也会通货膨胀。这里要分清两个容易混淆的东西:惯用法与模式。惯用法是语言社区口口相传的小技巧——比如“用枚举实现单例”,它依附于特定语言,换语言就失效;模式是跨语言的结构共识——“保证唯一实例”这个意图,在 Java 里是枚举单例,在 Python 里是模块级变量,在容器时代是一行配置。惯用法会死,模式转生。1990 年代的许多争吵,吵的其实是把惯用法当成了模式:为某种语言的特定写法赋予永恒地位,水位一涨就成了笑话。而真正的模式讨论的从来不是写法,是意图——意图不死,转生不止。
膨胀与反思
通胀的第一个牺牲品是单例。单例的承诺很美:保证一个类只有一个实例,并提供全局访问点——配置、连接池、日志器,看起来都该是单例。企业级 Java 把它用成了默认值,代价随后逐项到账:单例是隐藏的全局状态,任何模块都能悄悄读写它,系统的耦合藏在“全局可达”四个字里;测试变成噩梦,单例在用例之间携带状态,测试的顺序影响测试的结果;并发隐患潜伏在延迟初始化里,双重检查锁的写法稍有不慎就是数据竞争;扩展性被静态方法锁死,想替换实现只能改调用方。社区后来发明了一个词:单例反模式。替代方案逐个上场:依赖注入容器接管单例的生命周期,实例还是唯一的,但创建与装配的权力还给了容器,测试时可以随时替换;无状态的工具退化成静态工具类;需要隐藏实现的改走工厂加接口。单例在 Java 世界的演进史,本身就是一部微缩的语言进化史:
// 饿汉式:类加载就造好,简单但可能浪费
private static final Singleton INSTANCE = new Singleton();
// 双重检查锁:高并发下的标准答案,volatile 不可少
private volatile static Singleton instance;
// 静态内部类:靠类加载机制保证线程安全
private static class Holder { static final Singleton I = new Singleton(); }
// 枚举式:最简洁,天然防反射与序列化攻击
public enum Singleton { INSTANCE; }
四代写法解决的是同一个问题,仪式一个比一个轻——直到容器出现,把问题整个端走:Spring 里一个注解声明作用域是单例,剩下的事容器全包,程序员连 getInstance 都不用写。这背后是一次权力转移,名字叫控制反转:以前是代码主动找依赖(new 一个,getInstance 一个),现在是容器把依赖送货上门(声明需要什么,运行时自动装配)。单例与工厂这两大创建型模式,在容器里不是被删除,是被内化成了默认配置——程序员不再手写模式,住在模式里。演进的方向始终如一:把样板从人手里收到机制里。单例没有消失,它被收编了——从“程序员手写全局变量”收编成“容器管理的生命周期”。收编的逻辑与上一章的 goto 如出一辙:保留能力,收缴随身携带的权力。
反模式的名单不止单例。上帝类——一个类管支付管发货管退款管导入导出,上千行逻辑堆在一起,改一处牵动全身;意大利面条代码——上一章判过死刑的 goto 遗产,在面向对象世界借尸还魂,表现为对象之间漫无边际的互相调用;循环依赖——A 注入 B,B 注入 A,启动时两个人互相等对方先起床。社区给这些症状建档立卡,统称反模式:看起来像解决方案,实则是问题的化身。反模式与模式是一体两面——模式是“前人验证过的对”,反模式是“前人验证过的错”,两本册子合在一起,才是完整的工程经验。只读上册的工程师,等于只背了药方没看禁忌。
工厂的通胀更滑稽:万能工厂。一个类负责创建系统里所有类型的对象,产品每增加一种,工厂就胖一圈;加新产品必须改工厂的老代码,开闭原则碎了一地;工厂与产品紧耦合,单元测试寸步难行。正确用法(每产品系列专属工厂)在书里写得明明白白,膨胀的从来不是书,是读者的手——“这里也用个工厂吧,反正不要钱”。过度设计的清单可以一路开下去:只有一个策略的策略模式、没有扩展需求的装饰器、简单对象硬套建造者。心理学家马斯洛的锤子在这里有了软件版:如果手里只有一把锤子,看什么都像钉子;如果刚学会设计模式,看什么都像没用模式的遗憾。模式是手段,不是勋章;为用模式而用模式的人,亲手把协作词汇变成了协作税。社区段子里那个查数据库的服务,从 3 个类膨胀到 30 个,多出来的 27 个类没有解决任何真实复杂度,它们解决的是作者的安全感。更微妙的是防御性设计:多写一层抽象,锅就多一个人背——“我这是按模式写的”成了质量事故面前的免责牌。税一旦开征,纳的就不再是代码,是信任。词汇的账本从来都是两栏:一栏记省下的协作成本,一栏记新添的表演成本;模式运动的全部历史,就是这两栏数字的拉锯。
反思的高潮发生在依赖注入接管企业级 Java 之后。Spring 这类容器把“谁创建谁、谁依赖谁”从代码里抽走,写进配置:需要单例,声明作用域即可,线程安全与生命周期容器兜底;需要替换实现,改配置不断代码,测试时注入替身轻而易举。单例、工厂的大量手写代码,被容器的几行声明取代。一批 GoF 模式在框架层面被“吃掉”了——正如诺维格预言的那样,表达力的水位上涨,礁石露出水面。但词汇留了下来:工程师依然说“这里注入的是个单例”“那个是工厂方法”,容器只是换了实现,没换语言。膨胀退潮之后,剩下的才是模式真正的遗产:一套让陌生人能快速谈论陌生代码的词汇,以及一条教训——任何降低协作成本的工具,都有变成协作税的潜力;税一旦开征,偿还它的不是更好的模式,是更少的手。还有一层更安静的遗产:框架把模式沉淀成了默认结构。今天的 Web 开发者没读过 GoF,却每天活在模式里——请求进来先过分发器(前端控制器),再进拦截器链(职责链),业务逻辑包在服务层(外观),数据访问藏在仓储背后(代理加适配器)。模式从“要学的知识”变成“默认的环境”,像盐溶进水:喝不出颗粒,处处是咸味。词汇的终极胜利,是让自己变得不再被提起。而硬币的另一面是:当模式沉进框架,程序员谈论设计的能力反而退化了——调用者不再需要知道自己在用策略还是命令,框架替他选好了。上一代人争论“该不该用策略”,下一代人根本没见过选择的存在。每一轮抽象都这样:它解决旧的认知负荷,同时制造新的无知;被解决的复杂度消失在视野里,被制造的无知在某天框架漏水时连本带利讨回来。这就是卷五主导约束的另一张脸:人脑的上限没有变,变的是上限以下的东西由谁来记——人,还是框架。
所以,本章的判断是:设计模式的固化,是软件业为跨越个人大脑上限而发行的一套通用货币——它让陌生工程师之间能用名字结算经验,把协作摩擦压到可承受的区间;但货币超发之后,模式从沟通工具异化成资历表演,工厂与单例的通胀史证明,词汇一旦脱离它要解决的真实复杂度,就会从资产变成负债。有人可以反驳:当 AI 能直接生成并解释代码,人还需要这套黑话吗?回答藏在模式的起源里:亚历山大的住户拿着模式跟建筑师讨价还价,靠的不是图纸,是名字——只要软件还是由一群人协作写给另一群人看的,谈论结构的词汇就不可或缺;名字会换,讨价还价不会消失。货币会贬值,交易不会停止。
第 051 章 1979:MVC 与状态解耦的四十年轮回
1979 年,施乐帕洛阿尔托研究中心(Xerox PARC)的一间实验室里,一台 Alto 计算机的屏幕上开着几个重叠的窗口。Alto 是图形界面的先驱:鼠标、窗口、图标,今天习以为常的一切,在当时都是刚出生的婴儿。程序员用鼠标点中一个按钮,按钮凹下去,背后的一串数字变了,另一扇窗口里的图形跟着重画——三个动作,一次点击,屏幕上所有相关的东西都对上了。观众看到的是魔法,写程序的人看到的是债务:按钮的显示逻辑、数字的计算规则、图形的重画条件,三种代码搅在同一个方法里,改显示怕碰坏规则,改规则怕漏改显示。每加一个窗口,搅在一起的代码就多一团。在场的挪威访客特里格韦·伦斯考格(Trygve Reenskaug)盯着这次点击看了很久。他是奥斯陆大学的教授,来 PARC 访问,带着一个困扰:在 Smalltalk 里写图形界面程序,状态散落在各处,改一个显示要翻遍半个程序,程序员的大脑成了唯一的集成点。访客的身份在这里很关键:PARC 本地人沉浸在图形界面的狂欢里,觉得一切只是工程量问题;外来者没有这种钝感,他看到的是结构问题——不是代码写得不够多,是代码没有地方放。他在当年 12 月写下一篇论文,题为《模型—视图—控制器》(MODELS-VIEWS-CONTROLLERS),把一次点击拆成三个盒子。从那天起,软件世界花了四十年,反复争论这三个盒子到底该怎么摆。
三个盒子与三条线
伦斯考格的方案可以用一句话概括:把程序里三种不同的变化原因装进三个不同的地方。模型(Model)管数据与业务规则,是应用的真相;视图(View)管呈现,把真相画成用户看得见的样子;控制器(Controller)管输入,把用户的动作翻译成对模型的修改。三者的依赖方向是单向的:控制器与视图都依赖模型,模型不认识谁在显示它,也不认识谁在改它。一次点击的旅程在 Smalltalk-80 里走成固定路线:用户在视图上操作,控制器接管输入,修改模型,模型变化后视图更新。画在纸上是这样:
用户输入
│
▼
┌─────────────┐
│ Controller │ 翻译动作:点击 → 改模型
└──────┬──────┘
│ 依赖
▼
┌─────────────┐ 通知变化 ┌─────────────┐
│ Model │ ───────────────▶ │ View │
│ 真相与规则 │ ◀─────────────── │ 呈现与显示 │
└─────────────┘ 读取真相 └─────────────┘
这张图里藏着两个决定。第一,模型是唯一的真相来源,视图不存真相,只存画法;控制器不存真相,只存译法。状态散落的问题被釜底抽薪:以后找状态只去一个地方。第二,依赖是单向的,模型位于依赖链的底端,改模型不需要惊动任何人,换视图不需要重写规则。伦斯考格最初是为 Smalltalk 的图形界面设计这套切分的,桌面程序的状态变化来自鼠标与键盘,输入输出都在同一台机器、同一个进程里,三元切分管的是“显示与逻辑别搅在一起”。几乎所有后世的 MV family 都是这个三元组的修改版,多一个字母,少一根线,骨架都从这里来。在 Smalltalk-80 里,一次改名走的是这样的消息链:视图收到用户的改名输入,把 changeName 消息发给控制器语义,控制器调用模型的改名方法,模型更新后广播变化,所有依赖它的视图重画。消息是 Smalltalk 的母语,MVC 在这里与其说是三层调用,不如说是一群对象互相发消息,依赖方向靠约定维持,靠小规模团队的默契维持。这也是它后来在大型组织里屡屡走样的远因:约定在十个人的团队里是纪律,在三百人的团队里是建议。Smalltalk-80 在 1980 年把这套东西装进发行版,MVC 从论文变成每个 Smalltalk 程序员开箱即用的脚手架。脚手架的普及意味着误用的普及:三个盒子人人会摆,摆对的人寥寥,控制器里长业务、视图里藏逻辑,从第一代用户开始就没有断过。模式的命运在发行那一刻就注定了:它会被大多数人用歪,被少数人用对,歪的用法养活培训业,对的用法养活经典。Smalltalk-80 的发行把 MVC 从 PARC 的实验室带进全世界的课堂,教科书把它画成三层方块图,学生照着摆,摆完发现控制器里全是业务——方块图没讲的那半句,是依赖的方向。图会画的人多,方向守得住的人少,这是所有架构模式的共同命运:画在纸上的永远比守在代码里的多。
有意思的是,这套日后统治 Web 开发的模式,在正统设计模式的殿堂里并没有牌位。四人帮(GoF)在归纳 23 种设计模式时,没有把 MVC 收作正式模式,只把它看成解决问题的一些类的集合。在 GoF 的眼光里,MVC 更像观察者等几个模式的组合应用,不配单独占一个名额。这个冷遇恰好说明 MVC 的性质:它不提供一段可复用的代码,它提供一种分工协议,规定“谁允许知道谁”。协议的价值不在代码复用,在人脑减负:程序员一次只需要装下三个盒子里的一个,改显示的人不必读懂规则,改规则的人不必操心像素。后世的误读多半从这里起:人们把 MVC 当成三层文件目录,控制器里堆满业务,模型里只剩数据访问,视图里混着逻辑,美其名曰分层。原初愿景里,模型是活的业务,控制器是薄的翻译,视图是哑的显示;三者的边界按“变化原因”划分,不按文件类型划分。变化原因不同,修改的节奏就不同:业务规则随市场变,显示随审美变,输入随设备变。把节奏不同的东西锁在同一个文件里,每一次修改都要惊动另外两种节奏的人。拆节奏,才是 MVC 真正要干的事。按目录分层是果,按变化节奏分工是因,倒果为因的分层,盒子再多也是 Model 1。
从桌面到请求—响应
MVC 离开 PARC 之后遇到的第一次大考,是万维网。HTTP 协议是无状态的,请求来一次走一次,服务器画完页面就忘掉用户,桌面时代“常驻内存的模型与视图”在这里不存在。经典 MVC 不得不变体,变体的名字叫 Model 2。1990 年代末到 21 世纪初,Java 世界的 JSP 把 Web 开发带进 Model 1 时代:一个 JSP 页面里混写显示、业务逻辑与流程控制,写得飞快,一个文件从头管到尾。小团队爱它,理由直白:改一个页面只开一个文件,分什么层是吃饱了撑的。Model 1 的辩护者在当时占上风,还有一层说不出口的真相:Web 应用的寿命预期很短,今天上线的促销页下周就下掉,为只活七天的页面搭分层的骨架,经济学上不划算。快消代码配快消结构,天经地义。问题是,没有哪行代码真的只活七天:促销页长成频道,频道长成平台,当年“临时写写”的 JSP 一年比一年难动,动一处塌一片。所有泥球的墓志铭都一样:当初只是临时写写。Struts 1.1 在 21 世纪初扛起 Model 2 的大旗:引入 Servlet 扮演控制器的角色,请求先进控制器,再调模型,最后转发到 JSP 视图。Struts 的机器由三个零件组成:ActionServlet 是总入口,所有请求先到它这里报到;Action 是具体的业务动作,表单提交对应一个 Action;ActionForm 是表单数据的搬运工,请求里的字段先装进它,再递给业务。三个零件各有其主,请求在里面走固定的流水线:收请求、装表单、调动作、选视图。小团队看这套流水线觉得繁琐,大团队看它觉得安心——繁琐是写死的,安心也是写死的,写死的规则不需要开会统一。同一套三元组,在 Web 上长成新的形状:
浏览器 ──请求──▶ Controller(Servlet) ──调用──▶ Model(业务)
│ │
└────转发────▶ View(JSP) ◀──────┘
│ 只负责画
▼
响应页面
Model 1 与 Model 2 之争,是 MVC 历史上第一次严肃的反对意见,而且反对者完全理性。Model 1 派的账本摆在桌面上:同一个需求,Model 1 用一半的文件写完,调试时顺着一个文件从上读到下,不用在三个目录之间跳;Model 2 把简单请求也拆成三截,改一个字段要同时碰控制器、模型与视图, 仪式比业务还多。小项目里,分层不是解耦,是添乱。这笔账在当时算得没错,错的是外推:当页面从几十涨到几千,当写代码的人从三个变成三百个,Model 1 的单个文件会膨胀成无人敢动的泥球,所有的修改都在互相踩脚。Struts 讲出的道理不是“分层更优雅”,而是“分层让并行开发成为可能”:模块概念划分之后,不同小组各守一段,互不阻塞。控制器的真正产品不是代码,是组织并行度。想想三百人的 Web 团队:甲组写商品列表,乙组写结算流程,丙组管用户体系,如果所有人的代码都搅在 JSP 里,每一次提交都在互相覆盖,每一次联调都要三组人坐在一起对账。Model 2 把请求入口收敛到控制器,把真相收敛到模型,视图只管画,三组人各改各的文件,合并时冲突面小了一个量级。2004 年前后兴起的 Ruby on Rails 把同一套分层带进动态语言世界,约定代替配置,控制器与模型的骨架由框架生成,程序员填业务。Rails 的杀手锏不是分层本身,是把分层的仪式压到最低:按约定命名文件,框架自动接线,十五分钟搭出博客的演示震惊了 Java 世界——原来 MVC 不必配 XML 地狱。 仪式的压缩改变了争论的标的:反对者原来反对的不是分,是分附带的文书工作;文书工作一薄,分层的净收益转正,小项目也开始用 MVC。工具决定模式的采纳半径,这条规律在 Rails 身上第一次显形,后来在 React 的脚手架、微服务的边车代理身上反复显形。Web 框架的 MVC 化在 21 世纪第一个十年完成,无人再争。争论的终点不是一方说服另一方,是规模替分层投了票:小到一定程度,分层是累赘;大到一定程度,不分层是灾难。分界线不在代码里,在团队人数与页面数量的乘积里。
但胜利埋下了新的混乱。Web 后端的 MVC 与 Smalltalk 的 MVC 只共享名字,管线完全不同:后端没有常驻视图,所谓视图是一次性生成的 HTML 字符串;控制器从翻译鼠标点击,变成翻译 HTTP 请求。后端程序员嘴里的模型越来越胖,业务规则、数据库访问、事务边界全塞进去,控制器越来越瘦,只剩路由转发。胖模型瘦控制器的格局一形成,MVC 在后端就变了味:三个盒子名义上还在,第二个盒子常常只剩转发,第一个盒子臃肿到需要二次切分。胖模型的病根在请求—响应的形状:一次请求要穿过校验、鉴权、业务、持久化四道工序,全塞进模型,模型就成了第二个泥球。后世的各种分层、领域层、服务层,治的都是这场病:把模型再切一次,校验归一处,业务归一处,数据库访问归一处,切口与当年伦斯考格的刀法一致,只是这次切的是服务器内部。分层的轮回在这里显出它的递归性:每一层长大之后,都要把当年切分它的那把刀,对准自己再来一次。名字相同的模式,在桌面与后端是两门亲戚,认祖认宗时要小心。
绑定魔法与视图模型
桌面世界在 Web 化之前,先走了一段自己的演化。1990 年代的 MVP 把控制器换成 presenter:视图彻底变傻,只管把事件转发给 presenter,presenter 持有逻辑,测起来比直接连着窗口的控制器容易得多。MVP 的动机是测试,这在今天看来平淡,在当年是刚需:桌面视图的测试要启动整个窗口环境,点按钮、读像素,慢而脆弱;presenter 是不依赖窗口的普通对象,单元测试毫秒级跑完,界面背后的规则第一次被测试网兜住。测试倒逼分层,分层反哺测试,这条因果链后来在 Web 世界重演:控制器瘦到只剩转发,恰恰因为转发的逻辑最容易测,重的业务沉进模型,由模型的测试兜底。一个模式能活多久,看它站在测试一边还是站在演示一边,MVP 选了前者。2005 年前后,MVVM 登场,名字里的新成员叫视图模型(ViewModel)。它的绝招是数据绑定:View 与 ViewModel 之间不需要手写同步代码,框架盯着两边,一边变,另一边自动跟上。微软的 WPF 把数据绑定做成一等机制,界面设计师在可视化工具里拖控件、绑字段,程序员在 ViewModel 里写逻辑,两边通过绑定声明对接,编译器与工具链在中间牵线。工具链在这里第一次成为分层的一部分:绑定声明是给工具读的,不是给人读的,设计师的拖拽生成绑定,程序员的编译校验绑定,工具替两边对账。手写同步的时代,对账靠人眼;绑定时代,对账靠工具。工具越聪明,人越可以无知——设计师不必懂逻辑,程序员不必懂像素,无知被制度化为分工的前提。制度化的无知是把双刃剑:分工顺滑时效率翻倍,工具链断裂时两边一起抓瞎,设计师看不懂报错,程序员找不到控件。
数据绑定是双向绑定的前身,也是它最体面的形态。MVVM 把“同步”从程序员手里收到框架手里,视图模型是专门为视图准备的模型:它不存真相,它存“真相在当前界面上的样子”,选中了哪一行、输入框里写到一半的字、按钮此刻该不该亮。真相还在模型里,视图模型是真相的投影加界面私货。这一层多出来,换回的是分工:设计师动视图不需要惊动逻辑,程序员改逻辑不需要重排像素。桌面团队的规模诅咒在这里第一次被谈成职业分工,而不只是代码切分。
但绑定是有代价的魔法。自动同步意味着数据的流向不再写在代码里,而藏在框架的绑定引擎里。小界面里这是蜜糖:声明几行绑定,同步全自动。界面一大,绑定的依赖网就织成谁也看不见的蜘蛛网:改一个字段,三处界面联动,联动又触发校验,校验又改回字段,循环依赖在运行时炸开,堆栈里看不到任何一条程序员写过的调用。循环绑定的恐怖在于它不报错:A 变触发 B,B 变触发 A,两边都没错,界面在两个正确的值之间抽搐,调试器停在哪一帧,哪一帧都是无辜的。程序员最后的手段是数绑定:打印依赖图,一个个解开,解到第三个,图已经画满一页纸。调试绑定问题像修漏电:现象在东,漏点在西,中间是框架的黑箱。AngularJS 把双向绑定带进 Web,把这套魔法的红利与账单一起带了过去。蜜月期里,表单开发快如闪电;蜜月期后,大型应用的团队开始怀念“代码里能看到数据从哪来”的日子。绑定的账单迟到但必到,这为 2013 年的单向革命攒足了民意。
状态回流与单向河
MVC 的第三站回到它出发的地方:用户界面。2010 年代初的前端是 jQuery 的天下,页面上的状态散落在 DOM 里:这个输入框的值、那个按钮的禁用态、远处列表的选中行,各自为政。改一处逻辑,程序员要亲手同步五六处显示,漏一处,界面与数据就分道扬镳。散落的根子在命令式的写法:每一次同步都是程序员亲手发起的调用,调用写在哪里,同步就发生在哪里;需求一改,调用链要重排,重排时漏掉一环,界面就悄悄撒谎。撒谎的界面是最贵的故障:程序没崩,数据是对的,用户看到的是错的,排查要从显示倒推回数据,链条越长,定位越难。jQuery 时代的前端深夜,多半花在这种“看起来没错但显示错了”的故障上。AngularJS 用双向绑定救场:视图与模型自动同步,改一边,另一边跟着变。小表单里这是蜜糖:输入框与变量绑定,敲字即同步,代码短到像不用写。蜜月期的 Angular 应用开发快得不讲道理,表单密集的后台系统几天上线。但蜜月有保质期,保质期的名字叫规模。Facebook 的规模把这条路堵死,内部先拼凑出 BoltJS 救急,工程师乔丹·沃克(Jordan Walke)随后提出激进想法:数据只朝一个方向流。与其让框架猜什么时候同步,不如规定死同步的方向,省下的猜测成本,换成多写的样板代码。这笔交易在小应用里亏,在大应用里赚,Facebook 的体量让它别无选择。
2013 至 2014 年,React 与 Flux 把这条河挖了出来。规则只有两条,写在所有声明式教程的第一页:数据向下流,事件向上传。父组件持有状态,通过属性自上而下传给子组件;子组件不直接改数据,只上报事件,状态的持有者改完再把新数据传下来。命令式与声明式的分野在这里。jQuery 时代的程序员写的是步骤:找到这个节点,把它的文本改成那个值,把那个按钮设为禁用,每一步都是对 DOM 的直接命令。步骤写得越细,状态与显示的对应关系越藏在步骤之间:读代码的人要脑内执行一遍,才能拼出界面最终的样子。声明式反其道而行:程序员只写“状态如此时界面该是什么样”,怎么从旧界面变到新界面,交给框架。React 把更新细节黑箱化,内部用虚拟 DOM 做对比,算出最小变更集,再动手改真实 DOM。虚拟 DOM 的本质是先算账后花钱:状态一变,先在内存里算出新界面与旧界面的差异,差异清单越短,真实 DOM 的手术越小。直接操作 DOM 的时代,程序员亲手决定每一刀切在哪里,切多切少凭经验;虚拟 DOM 把下刀的活收归框架,经验变成算法。算法不一定比最好的手艺高明,但它比最差的手艺有下限——而大型团队的性能下限,恰恰取决于最差的那段手写更新代码。开发者不再操心“怎么变”,只定义“变成什么”。这一让渡的前提是信任:相信框架的对比算法比手写步骤更少出错。在小界面里,手写步骤更快;在状态爆炸的界面里,相信机器比相信自己的细心更划算。同样的赌局出现了第四次:把人容易错的事交给机器,把机器算不清的事留给人。受控组件是这条纪律的最小标本:
// 受控组件:值来自外部,变化上报外部
function SearchBox({ value, onChange }) {
return <input value={value} onChange={e => onChange(e.target.value)} />;
}
// SearchBox 不知道 value 是什么,也不知道父组件拿它干什么。
// 它只知道:显示 value,上报 onChange。数据向下,事件向上。
组件不知道数据的用途,只知道显示与上报,这就是松耦合的全部秘密。状态提升一层,复用就多一分;状态下沉一分,耦合就紧一分。prop drilling 是这条纪律的自然副产品:中间层层转发自己不用的数据,只为送到深处的叶子。组合优先于传递,Context 留给真正全局的东西,每一条经验都是学费换来的。同一张表,加撇号是数据,不加是代码——早年的旧智慧在这里借尸还魂:界面是状态的纯函数,UI 等于 f(state),同一份 state 在任何时机渲染,界面一定一模一样。2014 年 Facebook 给出 Flux 作为官方的半成品方案,React 本体不管组件通信,Flux 补上缺口。Flux 的定位说来有趣:React 自称只管 MVC 里的 V,Flux 补上 M 与 C。四部件围成一个严丝合缝的环:用户动作包装成 Action,Dispatcher 按依赖顺序分发给各个 Store,Store 更新数据,View 读到新数据重渲染,渲染出的界面等待下一次动作。Dispatcher 的存在值得多看一眼:多个 Store 之间有依赖,先更新谁、后更新谁,顺序错了会读到半新半旧的数据;Dispatcher 持有依赖关系图,按拓扑顺序分发,一次动作下去,所有 Store 按正确的次序挨个更新,没有 Store 能插队,也没有 Store 会漏接。环里没有回头路,数据永远朝一个方向转:
┌── Action(发生了什么) ──▶ Dispatcher(按序分发)
│ │
│ ▼
└──────── View(重渲染) ◀── Store(唯一真相)
UI=f(state) 集中更新
随后诞生的 Redux 把单向流做成严格的中央处理器:整个应用只有一棵状态树,状态只读,改状态必须发起 Action,所有变更走一个纯函数入口,调试时可以时间旅行,一步步回放状态的每一次变化。时间旅行值得多说一句:传统调试是顺着时间往前追,断点停在出错处,往前翻调用栈猜原因;Redux 把每一次状态变化记成日志,出错之后往回倒带,看状态在哪一步走歪。调试从“推理过去”变成“重放过去”,偶现故障第一次有了可复现的现场。Redux 为解决真实具体的调试痛点而生,不是为优雅而生,这是它与无数昙花一现的状态库的根本区别:工具的寿命取决于它止住的疼有多具体。中间件是单向环上长出的第二层皮:日志、异步请求、崩溃上报,都做成进出 Store 的管道,Action 流进去,副作用办完,新的 Action 流出来。管道的顺序写在代码里,异步的因果第一次有了可读的形状——请求先发,加载后置,成功失败各归其位。前端异步的混乱被收进管道,管道的清单就是文档。单向数据流的环路画出来是这样:
┌─────────────────────────────────────────┐
│ ▼
State ──▶ View(UI=f(state)) ──▶ 事件 ──▶ 更新器 ──▶ 新 State
唯一真相 纯函数渲染 向上传 集中处理
这条河也有它的反对者,而且理由同样结实。第一是样板税:React 写同样的表单要比双向绑定多写三到五成的代码,受控组件的 value 与 onChange 样样不能省,简单场景里这是纯粹的仪式。第二是心智税:依赖数组、闭包旧值、无限循环,新人踩的坑一个不少,单向没有消灭复杂度,只是把隐式复杂度变成了显式复杂度。第三是性能税:状态一变,所有订阅者一起重渲染,Context 广播动辄全树更新,Redux 早期一个动作触发二十多个组件更新是家常便饭,精细化订阅又是一门手艺。反对者指出的每一条都是事实,支持者回答的也只有一条:显式的复杂度可以被工具追踪,隐式的不能。当应用大到一定规模,“能追踪”比“代码短”值钱,这笔账与三十年前 Model 1 输给 Model 2 是同一笔。
单向河挖通之后,支流很快长出来。Hooks 把状态逻辑从组件里抽成可复用的函数,多个组件共享同一段状态逻辑,不再需要层层传递;Context 把全局数据广播给整棵树,主题、语言、登录用户一处提供、处处可读,代价是广播一变、全树重渲染,频繁变化的状态塞进去就是性能陷阱;Zustand 一派走精准订阅路线,组件只订阅自己用的那片数据切片,两万个节点里只动该动的一个,用第三方库换回细粒度更新。Redux 没有死,它退守到真正需要严格数据流约束的大型应用:审计要求追踪每一次变更,协同编辑要求所有操作过中央处理器,时间旅行调试在排查偶现故障时无可替代。选型的争论从“单向还是双向”下沉到“多大的单向”:全局广播、精准订阅、中央处理,三种刻度对应三种规模。从 Flux 到 Redux 再到 Zustand,变的都是形状,不变的是河床——状态必须有唯一的家,数据必须朝一个方向流。
四十年绕了一圈,MVC 的名字还在,管的东西已经换了三代:桌面时代管的是鼠标与像素的分离,后端时代管的是请求与页面的分离,前端时代管的是状态与渲染的分离。三代分离治的是同一个病:人脑一次装不下的东西,必须切成一次能装下的块。伦斯考格在 1979 年切的是显示与逻辑,沃克在 2013 年切的是数据与事件,切口不同,刀法一致。每一代新人拿到这把刀,都先嫌它钝——Smalltalk 程序员嫌三个盒子不如一个方法顺手,JSP 程序员嫌三层不如一个文件痛快,React 新人嫌受控组件不如双向绑定省事。嫌钝是理性的,因为刀确实钝:分层永远增加跳转成本,单向永远增加样板代码。等规模上来,又都发现离了它不行。轮回的不是模式,是规模诅咒:状态总会膨胀到超过个人大脑的上限,超过的那一刻,切分就从可选项变成必选项。诅咒的残酷在于时机:切分必须在疼之前做,等疼了再切,泥球已经长成,切分的手术费比当初省下的仪式贵十倍。所有关于 MVC 的争论,吵的从来不是“要不要切”,而是“现在疼不疼”——疼的人觉得刀是救命的,不疼的人觉得刀是添乱的,两边说的都是实话。实话之间没有对错,只有时机:切早了,仪式吃掉本该冲刺的速度,小团队会被流程拖死;切晚了,泥球长成,手术费是当初省下的十倍,大团队会被债务压垮。架构师真正的活,不是选模式,是判断时机——在疼之前切,在疼死之前切完。MVC 四十年,给出的从来不是答案,是这道时机题。
历史至此可以收束成一句有主语、可被反驳的断言:MVC 四十年的每一次复活,复活的都是“状态必须有唯一的家”这条纪律——盒子的数量与名字可以换,纪律换不得;凡自称取代 MVC 的新模式,事后看都是给这条纪律换了一套新制服。反驳它的路也很清楚:找出一门长盛不衰的主流 UI 范式,它的状态长期散落各处、无需唯一真相来源却依然可维护,纪律即破。卷五的约束在这里显形:超大规模软件压垮的从来不只是机器,更是人脑的认知上限与跨组织协作的摩擦成本;MVC 这把刀,切的一直是后者——让三百个人不必共享同一个大脑,也能改同一份状态。协作摩擦有三个面孔。第一是并行度:分层之后甲组改视图、乙组改模型,合并冲突从“同一文件里的互相覆盖”降格为“接口两侧的各自演进”,冲突面小了,人数才能加上去。第二是契约:控制器与视图都依赖模型,意味着模型的接口是全队的契约,改接口要全队开会,不改接口各干各的;摩擦从代码里搬到契约里,契约比代码稳定,摩擦就小。契约还有另一面:接口一旦定死,模型的演进就被锁住,加字段要全队评审,历史包袱从代码里搬进契约里。分层没有消灭摩擦,它只是把弥散的摩擦收敛成可谈判的摩擦——可谈判,就是可管理的。第三是新人上手:新成员入职,先读懂一个盒子就能干活,不必先吞下整个系统;认知上限不再是团队规模的天花板,分层把天花板垫高了一层。四十年里,盒子的名字换了几茬,这三笔账一笔没变。凡谈 MVC 只谈代码优雅的,都是只看了刀,没看执刀的手——那只手是组织的规模。
第 052 章 1990s—2010s:康威定律与微服务架构的组织学投射
1968 年 4 月,一篇论文投进《哈佛商业评论》(Harvard Business Review)的投稿箱,题为《委员会如何发明?》(How Do Committees Invent?)。标题里的“委员会”是点睛之笔:康威不谈天才,不谈个人,谈的是委员会——一群人凑在一起,用开会的方式发明东西。委员会的发明物,长得一定像委员会本身:话语权大的派系,模块就大;互不往来的派系,接口就厚;和事佬的派系,就负责写胶水代码。作者梅尔文·康威(Melvin Conway)是个程序员,论文讲的却是组织社会学:在管理学的刊物上谈系统设计,在当年是跨界;在程序员看来,组织是背景板,在康威看来,组织是图纸本身。设计系统的组织,其产出的系统架构,会受制于该组织的沟通结构。按作者本人数十年后的回忆,这篇论文最神奇的出版特征,是它的论点句落在倒数第三段——核心思想藏在行文将尽处,居然通过了评审,得以发表。一个程序员在管理学刊物上,用藏在倒数第三段的一句话,预言了此后五十年的软件架构史:你画出的每一张架构图,都是你们公司的组织结构图。每一次架构之争,吵的都是技术,定的都是编制。编制的意思很具体:几个团队、向谁汇报、跨团队协作要开几个会。单体配一个全栈团队,吵架在代码评审里解决;微服务配数十个小团队,吵架在接口契约里解决。吵架的场所变了,吵架的总数没变——康威定律守恒的不是代码行数,是组织为协作付出的总能量。架构师能选的,只是这笔能量以什么形式支付:以合并冲突支付,还是以网络超时支付。
沟通结构即架构图纸
康威的论断可以画成一张对照表,左边是组织的沟通方式,右边是系统的形状:
组织的沟通结构 系统的架构形状
────────────── ──────────────
三个团队互不说话 → 三个模块互不调用
所有协调经过一个中枢 → 所有调用经过一个总线
团队按业务垂直划分 → 服务按业务垂直划分
临时项目组到处借人 → 共享库与公共模块蔓延
对照表的残酷在于它是双向的:组织决定架构,架构反过来锁死组织。三个互不说话的团队写出的三个模块,接口处长满误解;误解越积越深,团队越发不想说话。接口处的误解有具体的形状:字段含义对不上,错误码各说各话,超时时间一边三秒、一边三十秒。每一次联调都在为当初没开的会还债,债的利息是深夜的故障,是周末的回滚。架构与组织互为因果,转起来就是飞轮,顺时针是协作,逆时针是内耗。康威定律常被误读成管理鸡汤,它的原意更接近物理定律:沟通带宽是有限的,跨越组织边界的每一次协调都要付费,系统设计者会无意识地把高频协作收敛到组织内部,把低频协作推向组织边界。架构图上的每一根线,都标着沟通的价格;画线的人以为在谈技术,其实在谈谁跟谁说话方便。康威的论断可以写成半句伪代码,挂在每个架构评审的墙上:
# 组织沟通结构 → 系统架构形状(康威映射)
# if 团队 A 与团队 B 从不说话:模块 A 与模块 B 之间必有一层厚接口
# if 所有协调经过中枢团队:所有调用必经过中央节点
# if 团队按业务垂直划分:服务必按业务垂直划分
# 评审架构之前,先画出组织结构图;两图不一致,必有一图在撒谎。
```价格有明码:一家虚构的保险公司,六十名工程师分成网页、服务、数据、运维四队,系统的边界长得和四队的边界一模一样——不是设计出来的,是开会开出来的。谁和谁每周例会,模块之间就长出调用;哪两个团队共用一个主管,它们的代码就共享一个库。评审会上争的是接口,接口背后争的是编制。
定律提出后的二十年,它更像段子而非工具。软件系统还小,一个团队写完整个系统,组织与架构的张力不明显。转折发生在 1990 年代:企业买了一堆互不兼容的系统,财务一套,人事一套,仓库一套,销售一套,每套都自称行业标准,合起来是谁也不认识谁。异构的现实摆在面前,集成成了显学:怎么让说不同语言的系统互相办事?答案在 2000 年代初成形,名字叫面向服务的架构(SOA):把每个系统的能力包装成服务,服务之间用统一的总线互联。总线的名字叫企业服务总线(Enterprise Service Bus,ESB),职责是中枢神经:消息路由、协议转换、数据格式转换。销售系统要通知仓库发货,ESB 把销售口径的订单信息翻译成仓库口径的格式,再传过去。翻译官坐镇中央,方言各异的系统第一次能对话。
ESB 的动机在当时无可指摘,而且有战绩背书。某银行用 ESB 整合 20 个遗留系统,新业务的开发周期从 6 个月缩到 2 个月;2000 年代中期,每家主流企业软件厂商的路线图上都有一条 ESB,IBM 的 WebSphere 只是其中最显眼的一面旗。厂商的路线图本身就是风向标:当所有大厂在同一品类下注,说明买方市场已经用订单投了票。CIO 们的算盘很实在:重写 20 个遗留系统要五年,期间业务不能停;上一条总线,一年见效,任期内能交差。任期政治与技术选型在这里合谋:见效快的方案永远打败正确但慢的方案,ESB 赢在见效快。反对的声音当时也有,多半来自一线工程师的直觉:所有翻译都经过一个中央节点,这个节点会不会成为瓶颈?翻译规则越积越多,中央节点会不会变成第二个泥球?直觉被战绩压了下去:银行的例子摆着,周期缩短了三分之二,瓶颈是以后的事,先把眼前的集成做完。这笔账在 2004 年算得没错,错的是外推——人们以为中央节点的容量可以随业务线性增长,实际上翻译逻辑的复杂度是超线性增长的,每新增一个系统,要写的不是一份翻译,是它与所有已在总线上系统的方言对照表。
### 失败案例:企业服务总线如何退化为中央垃圾场
先把 ESB 全盛期的账本摆全,因为不摆全,后面的清算就不公允。2000 年代初的企业 IT 现实是:一家中等规模公司的机房里,跑着三四代技术栈,主机上的 COBOL、客户端上的 VB、新上的 Java,谁也不服谁。业务要上线一个“下单后自动扣库存、触发物流、生成财务凭证”的流程,横跨四个系统,四种协议,四种数据格式。点对点集成的代价是网状连接:四个系统两两对接要写六份接口,五个系统要写十份,接口数随系统数平方增长,新增一个系统,全网重写。点对点的账本在系统少时是赚的:两三个系统,直接连,快;系统一多,网状的边数爆炸,每条边都是一份要维护的契约。ESB 把网状压成星形:每个系统只管把自己翻译成总线的普通话,翻译一次,处处可用,新增系统只写一份接入。星形的账本在系统多时是赚的,代价是中央节点的容量与复杂度同步膨胀。银行的战绩是这套逻辑的完美验证:20 个遗留系统不动,ESB 居中转译,新业务只管调用总线,周期从 6 个月压到 2 个月。在异构是既成事实、重写既不可能的约束下,中央翻译是唯一可行的调度,ESB 的设计者解决的是真问题,拿的是真战绩。把后来的失败倒推成“当初就不该集中”,是事后诸葛亮——2003 年没有人能开出第二张药方,去中心的消息队列、容器编排、云原生网关,这些药引还要再等十年才配齐。
垃圾场的形成不是一天写成的,是三年攒成的。第一年,总线干净,路由清晰,翻译规则十几条,团队为交付速度欢呼。第二年,新系统接入,老系统升级,方言对照表从十几条涨到几百条,开始出现“销售口径的订单”与“财务口径的订单”在总线里打架,翻译的翻译叠上去,规则开始引用规则。第三年,无人敢动:改一条转换规则,不知道会断掉下游哪三个系统的财报;加一个新接口,要回归测试半条总线。ESB 的代码库成了企业里最大的单体——讽刺的是,SOA 的旗号恰恰是“拆单体”,拆出来的业务单体,借尸还魂成集成单体。维护总线的团队从架构师变成救火队,排期表上全是“不敢动”的注解:这段映射是 2005 年某次促销写的,写的人已经离职,动它之前先烧香。
压垮信心的有三根稻草,根根都打在当初的优点上。第一根是单点故障:ESB 挂了,所有服务全部瘫痪。当初“翻译一次处处可用”的星形拓扑,反过来就是“一处宕机处处停摆”。银行的核心交易不敢把身家押在一个进程上,ESB 越重要,围绕它的高可用投入越大,高可用的成本吃掉集成省下的钱,只是时间问题。第二根是性能瓶颈:所有流量经过中央节点,某电信系统的忙时洪峰把 ESB 打成漏斗,服务们空转着等翻译。去中心的支持者后来算过一笔账:点对点慢在开发,中央慢在运行,开发的慢是一次性的,运行的慢是每分钟都在交的税。第三根最致命,叫超级大国:路由规则、转换规则、业务规则全部沉淀在总线里,总线团队事实上审批全公司的业务变更——改个字段要总线团队排期,业务方等三个月是常态。当初为解耦而设的中枢,长成了耦合最深的权力中心。想动它的业务方发现,ESB 的会议比架构评审还难约。
清算发生在 2008 至 2012 年,演进线走成四段:单体部署,到 SOA 加 ESB,到微服务加容器与 API,再到 Kubernetes 编排。每一段的交接都不是技术换代,是组织规模换代:单体对应一个团队全栈,SOA 对应多团队分系统,微服务对应团队数超过白板能画下的架构图,Kubernetes 对应连机器都不想管的平台部。技术名词的更替史,背后是一张编制膨胀表。ESB 的真正教训不是“集中错了”,是“集中的度会自己生长”:任何中央节点,只要允许往里加逻辑,逻辑就会一直加到它崩溃;不设上限的收敛,终点都是垃圾场。垃圾场里埋的不是蠢人,是三年里每一次“先加上、以后再拆”的理性决定。
### 一次停机引发的迁徙
微服务的口号直白到粗鲁:拆掉邮局,人人讲普通话。邮局的比喻值得拆开:邮局的好处是寄信人不用知道收信人的地址细节,写好收件人,邮局分拣;邮局的坏处是所有信都经过分拣中心,分拣中心着火,全城断信。拆掉邮局不是不要送信,是改成点对点直送:每个服务自己写地址、自己贴邮票,直送的慢(开发时多写)换来分拣中心消失(运行时无单点)。但直送有个前提:人人讲普通话。普通话就是轻量协议:HTTP 加 JSON,谁都懂,谁都便宜。当年的方言对照表没有消失,只是从中央邮局的墙上,搬进了每个服务自带的小册子。每个服务独立,服务之间用轻量协议直接通信,翻译逻辑下沉到各服务内部,中央不再设翻译官。ESB 厂商的路线图一夜之间改写,同一批销售开始卖 API 网关与集成平台。但公允地说,微服务没有消灭翻译,它只是把翻译费分摊了:今日微服务架构里的消息队列、 schema 注册表、网关转换插件,干的仍是当年的活,只是账本从中央总账拆成了各家小账。小账的好处是爆了只炸一家,坏处是总成本未必更低——分布式事务、链路追踪、版本对齐,这些新账单在 ESB 时代是不存在的。分布式事务尤其讽刺:单体时代一个数据库事务搞定的事,拆开之后要拆成多步、配上补偿动作逐段确认,正向逆向写两遍,补偿逻辑比业务还长;链路追踪是为了回答“一个请求到底经过了谁”,请求一进系统就领一个身份证,每个服务盖章,事后按号查岗——ESB 时代不需要查岗,因为所有调用都经过中央,日志天然齐全。微服务把当年的免费午餐,一样样标上了价。
微服务的第一块丰碑立在 DVD 的灰烬上。2008 年 8 月,Netflix 的数据库损坏,DVD 发货停了三天。DVD 租赁是 Netflix 当时的全部家当:用户在网站下单,仓库发货,快递上门,停三天意味着三天没有新碟寄出,客服电话被打爆,竞争对手的广告趁虚而入。停三天的直接损失是租金与商誉,深层损失是信心的崩塌:单体应用基于 Java 与 Oracle 构建,所有业务逻辑耦合在一起,数据库一出问题,整个系统没有任何服务可用。一台数据库的故障半径等于全公司,这就是单体的代价公式。公式的另一面是:单体时代的每一次扩容、每一次发布、每一次故障演习,半径都是全公司;全公司半径的事项,一年能做几次?扩容要全公司停机窗口,发布要全公司回归测试,演习要全公司配合,事项的成本随半径平方增长。一年下来,敢做的变更越来越少,系统越来越稳,也越来越僵。稳和僵是同一种状态的两个名字,区别只在于董事会看的是哪一面。Netflix 的答案是迁徙:把系统迁上 AWS,把单体拆成数百个独立服务,每个服务负责一个明确的业务领域。选 AWS 而不是自建机房,本身就是康威定律的一次应用:自建机房意味着养一个机房团队,机房团队的排期会成为所有服务的瓶颈;用云,机房团队消失,瓶颈消失,组织少一层,架构少一结。这场迁徙走了约 7 年,不是一次重写,是一次器官移植:旧单体还在跳动,新服务一个个长出来,接管一块业务,再掐掉旧单体里对应的一块。7 年里公司不能停摆,用户不能感知,移植在行进中完成。做法只有一个:新旧并存,逐块替换,旧的不退役,新的不上位。
拆开之后的第一笔红利叫故障隔离。数百个服务各自独立部署,一个服务挂了,挂的是它负责的那块业务:推荐挂了,播放不受影响;账单挂了,浏览不受影响。故障半径从全公司缩小到一个业务域,这是当年 Oracle 故障的镜像形状。独立部署还带来第二笔红利:发布解耦。单体时代,全公司共用一个发布火车,一个团队的回归失败,全车人陪着等;发布窗口一月两次,错过一班等半月,紧急修复也要搭火车,不能单独发车。火车时刻表是全公司的瓶颈,时刻表之外的一切需求都要排队。服务拆开,各发各的,一天发布几百次成为日常,紧急修复十分钟上线,不用等任何人。发布火车的消失,解放的不只是速度,更是责任:谁的代码谁发布,谁的故障谁回滚,故障的归属第一次清晰到个人。第三笔红利是伸缩:播放压力大,只扩播放链路的服务,不必为整个单体加机器,云账单第一次能精确到业务。每一笔红利都在付同一笔对价:分布式的复杂度。网络会抖,时钟会偏,服务会超时,重试会放大,一个业务变更要跨五个服务对齐。Netflix 为这笔对价建了一整套韧性工程,最出名的是混沌猴(Chaos Monkey):在生产环境随机杀死服务器实例,看系统能不能自愈。猴子的杀法是状态机:挑一台健康的在线实例,随机选中,终止,负载均衡把缺口补上,观察流量是否自动绕开尸体。随机杀戮听起来疯狂,逻辑却诚实:与其等故障在深夜自己上门,不如在白天主动请它来,来的次数多了,值班的人就知道每一处会怎么断、该怎么接。资源争用、第三方故障、人因错误、云环境的动态性,这些在单体时代靠“机器在机房里不会动”掩盖的问题,在云上全暴露了,混沌工程是把暴露变成演习的办法。演习还有第二层含义:它逼每个服务都写好自愈,不会自愈的服务,在猴子面前活不过一周。
Netflix 的迁徙常被讲成微服务的胜利宣言,公允的讲法是:它证明的是“大到一定程度,单体必死”,没证明“小到任何程度,微服务都活”。数百个服务的治理成本是天文数字:服务发现、配置分发、链路追踪、版本兼容,每一项都要专职团队。服务发现是第一道坎:服务实例在云上生生灭灭,地址随时变,调用方不能写死地址,要问注册中心;注册中心自己要是挂了,全网失明。配置分发是第二道坎:几百个服务的开关、阈值、地址,改一个配置要全网生效且可回滚,配错一个数字,半夜被告警叫醒。版本兼容是第三道坎:服务 A 升级了接口,服务 B 还没跟上,新旧并存期谁迁就谁,契约的版本号就是谈判桌。Netflix 养得起专职的平台团队,养不起的中小公司照抄,只会得到分布式单体——服务拆开了,发布还得全家一起发,一个变更跨五个仓库,延迟与僵局一个不少。微服务的门票不是决心,是平台能力。2008 年的三天停机买的是教训,不是药方;药方是 7 年迁徙里长出来的平台肌肉,肌肉长不出来,药方就是毒药。
### 边界与边车
拆成数百个服务之后,第一个要命的问题是:边界划在哪。划错了,分布式单体;划对了,各自安好。分布式单体是最贵的失败:付了分布式的全部代价——网络延迟、部署协调、故障排查跨机器,却没拿到自治的任何红利——一个业务变更要同时改五个服务、同时发五个版,少发一个,全网对不上。判断自己是不是分布式单体,方法很简单:数一次常规需求变更要动几个仓库,动几个发布计划;超过两个,就是单体穿着微服务的衣服。这个问题在 2003 年就有人给出方法论:埃里克·埃文斯(Eric Evans)在《领域驱动设计》(Domain-Driven Design)里提出,用“限界上下文”给业务划界。DDD 的工作方式反直觉:程序员先闭嘴,让业务专家把话说完,把“订单”在三个团队嘴里的三个意思原样记下来,再按意思划界,而不是按技术分层切分。业务与技术专家的协作是 DDD 的硬性要求,模型是两个人一起写出来的,不是程序员关起门翻译的。翻译会走样,对话不会——至少走样时双方都在场。一个中型电商系统里,“订单”在交易团队是待支付的购物车快照,在物流团队是等待拣货的配送单,在财务团队是一条应收账款记录。三个团队共用同一张订单表、同一个订单服务,每次迭代都互相踩脚:交易加字段,物流的报表崩了;财务改状态机,交易的下单卡住。DDD 的回答是:不要共用,让三个“订单”各自独立,上下文之间用明确的翻译层对话,不要用共享的表偷懒。限界上下文的思想与康威定律是同一枚硬币的两面:康威说组织长什么样系统就长什么样,DDD 说先想清楚业务有几个意思,再让组织与系统照着意思长。从业务视角划领域边界,建领域模型,再把领域模型映射成微服务的代码模型,服务的边界第一次有了业务语义背书,而不是按技术层次一刀切。上下文之间对话,不靠共享的表,靠明确的翻译层:交易上下文的“订单已支付”事件,翻译成物流上下文的“待拣货单”,翻译逻辑写在边界上,不渗进任何一方的内部。边界越清晰,翻译越薄;边界越模糊,翻译越厚,厚到最后,翻译层本身长成第四个上下文——这就是 ESB 借尸还魂的形状,翻译官永远想当国王。国王的诞生不需要阴谋,只需要便利:每个上下文都觉得“翻译扔出去最省事”,扔的人多了,翻译层收到全公司的逻辑,逻辑多了就要排期,排期就有了权力。权力不是夺来的,是图省事的人主动上交的。DDD 的翻译层之所以规定“薄”,薄的不是代码,是权力——翻译层只许转述,不许决策,转述一旦开始决策,国王即位。
边界划对了,第二个问题浮上来:数百个服务的治理,代码怎么写。早期的答案是框架:每个服务集成一套客户端库,管发现、管重试、管熔断。框架的问题是语言锁死与升级地狱:Java 服务与 Go 服务各搞一套,框架升级要全公司服务逐个发版。2016 年,服务网格(Service Mesh)登场,9 月 29 日首次公开使用,2017 年初进入国内技术社区视野。网格的绝招叫边车(sidecar):每个服务旁边停一辆代理小车,流量进出都经过它,治理逻辑写在小车里,不在业务代码里。画出来是这样:
服务 A ──▶ [边车 A] ═══════▶ [边车 B] ──▶ 服务 B
│ 发现/重试/熔断 │ 业务代码
│ 加密/限流/追踪 │ 只管业务
▼ ▼
控制面(统一下发策略,不碰流量)
数据平面与控制平面解耦:小车们负责转发,中央的控制面负责下发策略。业务代码从此不必知道治理的存在,换语言、升版本,小车照跟。无代码侵入是边车最狠的一刀:框架时代,治理逻辑与业务代码编译在一起,升级治理等于重新编译业务,Java 的版本与 Go 的版本各搞一套,谁也别想统一;边车时代,治理是独立进程,业务是独立进程,两边只通过本地回环通信,治理升级只发小车的版,业务无感。语言锁死与升级地狱一起消失,代价是每台机器上多跑一个进程,多一跳本地转发。多出来的进程与转发,在当年是不可接受的浪费——机器按台买,进程是成本;到容器时代,进程的成本摊薄到忽略不计,浪费变成了划算。技术的账本随硬件价格重写,昨天浪费的,明天标配。早期的替代方案是 API 网关,毛病有三:所有流量经过网关,网关既是性能瓶颈,又是单点故障;治理粒度粗,只能管到网关这一层,管不到服务与接口;东西向流量(服务之间互调)基本管不着。边车把治理推到每个服务门口,粒度细到接口,网关管南北,边车管东西。Istio(Google、IBM 与 Lyft 联手)、Linkerd(Twitter 血统)、Consul,先后入场,Istio 以社区活跃度成为标杆。标杆的含金量不在功能多,在“不用选”:三家鼎立时,架构师最怕选错,选错的代价是三年后迁移;标杆出现,选它,错也是随大流错,责任共担。技术选型的政治学在这里压倒工程学:最好的不一定赢,最不会错的一定赢。边车的本质是治理下沉:把当年 ESB 中央做过的事,拆成每服务一份,下沉到基础设施层。历史在这里转了个圈:从中央邮局,到拆掉邮局,到给每家门口配一个小邮筒。邮筒与邮局的区别在于,邮筒不翻译业务,只管送信;翻译的活,留给各服务自己。
卷五的约束在这里收束为人话:超大规模软件的敌人,从来不只是代码的复杂度,更是组织沟通的摩擦成本。组织沟通有三副面孔。第一是带宽:人一周能开的会有上限,能读的文档有上限,能记住的接口有上限,架构的复杂度一旦超过沟通带宽,理解就退化成猜测,猜测就长成误解。第二是时延:跨团队的一个问题,邮件三天、会议一周、对齐一月,时延越长,协作越倾向于绕过对方自己干,自己干的影子系统越积越多。第三是失真:需求每经过一层转述,丢失一部分,三个团队串行转述,到末端剩下的与初衷判若两人;失真无法消灭,只能缩短链条,让失真发生在边界之内。康威定律管的是“线怎么画”,DDD 管的是“界划在哪”,服务网格管的是“治理谁来扛”,三者的共同答案是:让沟通的结构与系统的结构同构,同构之外的每一次跨越都要明码标价。微服务的全部创新,可以读成一句话:承认组织是拆不散的,于是把系统照着组织的样子拆好,让每一次协作都发生在边界之内。边界之内是自治,边界之外是契约,自治越彻底,契约越值钱。
历史至此可以收束成一句有主语、可被反驳的断言:微服务不是架构的进步,是组织学的一次诚实——它用网络调用的显式代价,替代了组织沟通的隐性代价,让每一次“跨团队协作”都变成账单上可计量的一行;当协作顺畅到不需要拆分时,单体就是更便宜的正确答案。诚实的另一面是账单的刚性:显式代价省不掉,网络延迟摆在那里,超时重试摆在那里,唯一的调节阀是拆分的粒度。粒度太粗,协作摩擦回来;粒度过细,运维账单爆炸。架构师的活从“选单体还是微服务”变成“在组织的沟通结构上找切分点”,切分点找对,技术选型只是填空。可反驳的路标同样清楚:找出一家长期保持数百人规模、组织沟通顺畅、却始终跑在单一单体上且迭代速度不输微服务同行的公司,断言即破。架构没有先进落后,只有与组织沟通结构的匹配程度——匹配是唯一的裁判,技术只是记分牌。裁判的难处在于,组织结构比架构难改:代码可以重构,编制重构要动绩效、动汇报线、动办公室政治。绝大多数“架构升级”失败,不败在技术选型,败在组织纹丝不动,旧组织穿着新架构的衣服,身不由己地长回旧形状。康威定律的真正用法,从来不是“照着组织画架构”,而是“想画什么样的架构,先建成什么样的组织”。
---
## 第 053 章 1970s—2010s:并发状态管理的正确性求索
压测的第几百万次运行里,计数器第一次对不上。代码评审过三遍,逻辑没有问题,单线程跑一万次全对;可一旦上了多核,几百万分之一的概率,总有一个请求读到半截更新的数据。更麻烦的是,双重检查的单例在流量高峰偶尔返回一个没构造完的对象——字段还是零值,方法调上去直接崩溃。最折磨人的是复现:在测试环境跑一夜风平浪静,上线第一天就在高峰现形;加日志想抓现行,多出来的同步又把交错的时机改变,bug 闻风而逃。观察者效应在这里是字面意义:看它的动作本身,就是在改变它。重启,压测,通过,上线,复发。并发的 bug 从不现场留名,它只在深夜的告警里现身一次,随即消失,等着下一次高峰。本章的问题就从这里开始:多个控制流同时修改同一片内存时,人类凭什么保全事实的真相?四十年里,答案换了四套写法:锁、CAS、内存模型、消息与协程;每一套都是把机器的真相翻译成人能理解的形状。
### 锁的代价:从互斥到乐观
锁是最直观的答案:一次只允许一个线程进入,别人排队。直观的代价是阻塞——等待的线程被挂起,上下文切换的开销以微秒计;竞争越激烈,挂起与唤醒的队伍越长,锁把并行退化成串行。粒度的两难随之而来:锁得太粗,并行度被吃掉;锁得太细,加锁顺序记不住,死锁在某个深夜不期而至。锁的正确性押在程序员脑子里的加锁图上,图的规模随线程数膨胀,超过记忆容量的那一刻,错误就从可能变成注定。锁的家族还有分工:读写锁让读与读并行,只在写到来时清场,读多写少的场景下吞吐量翻番;自旋锁让等待的线程原地空转,临界区极短时比进出内核划算,临界区一长就变成全员空耗。死锁是最经典的锁事故:线程甲拿着锁一等锁二,线程乙拿着锁二等锁一,两个线程互相等到地老天荒,谁也不先松手。解法是统一加锁顺序:所有线程拿锁一律先一后二,环形等待从此无从形成;顺序是写进规范的,不是靠记的。银行转账是教科书的例子:从甲账户扣钱、往乙账户加钱,两步必须是原子,中间崩溃则账实不符;锁把两步包成一步,包的代价是转账期间两个账户都被冻结。冻结的范围越大,并发越低;正确性与吞吐的跷跷板,从第一把锁诞生就没停过。选哪种锁,看的是临界区的长度与竞争的烈度——没有一种锁通吃,通吃的许诺本身就是陷阱。读写锁有它自己的升级陷阱:拿着读锁的线程想升级成写锁,另一个同样拿着读锁的线程也想升级,两个升级互相等,死锁在升级处现形。解法是升级前先放锁再重拿,或者从一开始就拿写锁;抄近道的每一步,都在给死锁攒材料。自旋锁的适用边界同样清楚:临界区只有几条指令、持有时间以纳秒计时,自旋比进出内核便宜;临界区一旦变长,或者单核环境根本没有“别人先跑”的机会,自旋就是纯烧。锁的选型手册只有一句话:先量临界区,再数竞争者,最后才选锁。悲观与乐观的分水岭在这里划定:悲观者假设冲突一定会发生,先排队再干活,为最坏的情况付确定的税;乐观者假设冲突很少发生,先干活再校验,冲突了重来,为最好的情况赌一把。锁是悲观的极致,CAS是乐观的起点;两种哲学没有对错,只有与竞争烈度的匹配度。
无锁编程把思路反了过来:事前不设防,事后重试。核心原语是 CAS——比较并交换:先读内存的值,比对是否与期望相符,相符才写入新值;整个读改写由硬件指令保证原子,x86 的 CMPXCHG 与 ARM 的保留加载条件存储指令对在总线层面锁住缓存行,不给其他核心插队的机会。失败的一方不阻塞,原地自旋重试:循环读一次,再比一次,直到成功。低竞争下,自旋几次就成功,比进出内核快得多;高竞争下,所有线程同时空转,CPU 被重试吃满,乐观锁结出悲观的果。组合的口诀是 volatile 负责看、CAS 负责改:前者保证读到最新值,后者保证改的原子性;两者搭配,才是无锁但正确的并发。口诀的边界同样清楚:CAS 只保证单个内存地址的原子,复合操作无能为力——要同时改两个变量,或者先读后算再写一串逻辑,老实回去用锁;竞争的烈度超过阈值,自旋的税超过阻塞的税,聪明的实现会准备回退策略,失败率一高自动切换成阻塞。乐观不是信仰,是低竞争下的划算;烈度一变,账要重算。硬件的脾气也要摸:多核同时对同一地址 CAS,总线锁定与缓存行失效风暴随之而来,自旋的线程越多,互斥的硬件开销越大;退避策略应运而生,失败了随机睡一会儿再试,把竞争的高峰打散。退避的随机不是偷懒,是数学:确定性的同时重试只会同时再撞,随机才能把人群错开。硬件、算法、策略三层叠起来,无锁的性能调优才算入门;入门之后,还有伪共享、NUMA 这些深水区——那是并行代价章的地盘。热点分散另有去路:把一个计数器拆成多段分开累加,需要总数时再汇总,碰撞的概率随段数下降——分段的思想后来长成了标准库里的可扩展计数器。分段的本质是把一个热点打成一片温热:每个线程写自己的段,读的时候才合并;写的冲突没了,读的代价多了一次汇总。汇总的频率远低于写入的频率,一多一少之间,吞吐量就被换出来了。
```cpp
void push(Node* node) {
Node* old;
do {
old = top.load();
node->next = old;
} while (!top.compare_exchange_weak(old, node));
}
CAS 的招牌陷阱叫 ABA。线程 1 读到栈顶是 A,准备把它换成 C;线程 2 先弹出 A,又弹出 B,再把 A 压回去;线程 1 执行比较,发现栈顶还是 A,通过——可它不知道 A 已经出去旅游了一圈。值相同,历史不同;CAS 只认值,不认历史。数值累加的场景里,旅游一圈不影响结果,ABA 只是理论缺陷;指针跳跃与内存回收的场景里,中间态意味着节点已释放,比较通过的那一刻,程序拿着一张过期的地图在已释放的内存上继续施工。解法有三档:版本号把值与单调递增的戳绑在一起比较,改没改过一目了然;标记位用一个布尔记录是否被动过,适合惰性删除的结构;延迟回收把物理删除推迟到安全窗口, hazard 指针与 RCU 机制确保没有线程再访问旧节点才动手。三档的代价递增,可靠性也递增;选哪档,看的是指针的身价。无锁队列是三档解法的综合考场:头尾指针各自由 CAS 推进,入队改尾,出队改头,两端各管各的,互不阻塞;ABA 藏在头指针的复用里,内存回收藏在出队节点的生死里,一个工业级的无锁队列,注释里一半是算法,一半是回收。队列的流行不是因为它简单,是因为生产者消费者是并发世界最常见的形状;形状越常见,值得付的验证费越高。hazard 指针的手艺值得多看一眼:读节点之前,先把“我在看它”登记在册;删节点的时候,先查花名册,有人登记就暂缓动手,过一会儿再来。登记与检查都是原子操作,开销摊在每一次读写上;花名册越长,检查越贵。标记位的局限在于只有一比特:它回答得了“动没动过”,回答不了“动过几次”;要数次数,还得请版本号出场。一比特与一整数之间,是精度与开销的长期议价。
看不见的顺序:内存模型
比 ABA 更深的麻烦是顺序本身。程序员以为代码按书写顺序执行,机器在三个层面同时撒谎:编译器在单线程语义不变的前提下调换指令,用寄存器、合并访问;CPU 流水线乱序发射,让不依赖的指令先跑,修改先落在核心私有的缓存里;缓存一致性协议让不同核心看到的写入顺序不一致,核心甲先看到 X 后看到 Y,核心乙看到的顺序可能正好相反。三层重叠的结果是:在一个核心上顺序写下的两个值,在另一个核心眼里可能是倒着抵达的。x86 是强内存模型,多数重排序被硬件兜底,少屏障的程序常常碰巧正确;ARM 是弱内存模型,该显式同步的地方一个不少,x86 上跑得好好的程序移植过去就翻车。移植的教训只有一条:把“碰巧正确”当成正确的程序,换一片硅就现形。
内存模型的回答是 happens-before:用因果替代细节。开发者不需要知道编译器与 CPU 具体怎么乱序,只需要知道哪些操作之间存在“必须先被看到”的关系:单线程内的书写顺序天然成立;对变量的写先于后面对它的读;锁的释放先于后面对同一把锁的获取;线程的启动先于新线程的一切,线程的结束先于等待它的人;关系可以传递,A 先于 B、B 先于 C,则 A 先于 C。满足这些关系,乱序随便排,结果必须等价;不满足,行为未定义,机器爱怎么写怎么写。传递性是因果链的胶水:线程 1 写普通变量 x,再以 release 语义写原子旗标;线程 2 以 acquire 语义读到旗标,则线程 1 写 x 的动作对线程 2 可见。旗标是摆渡的船,变量是过河的人;船到了,人就到了。发布与订阅、生产与消费,万变不离这条船;看懂 release-acquire,就看懂了无锁编程的一大半。因果是写给人看的,乱序是留给机器的;两者之间的翻译,就是内存模型的全部工作。
书写顺序 ──编译器重排──▶ 指令顺序 ──CPU乱序──▶ 执行顺序 ──缓存──▶ 他核所见
│ │
└──────── happens-before:因果链必须保 ─────────────────────────┘
单线程书写序 → volatile写→读 → 解锁→加锁 → 启动/汇合 → 传递闭包
这套契约的第一次工业落地是 JSR-133。2000 年,Java 社区流程发起对内存模型的重订;2004 年,它随 Java 5.0 发布。旧模型有三处硬伤:final 字段可能被看到中途状态,不可变的对象在别的线程眼里是半成品;理论上允许凭空造出从未被写入的值;为了安全禁止了大量合法优化,性能白白受损。新模型用 happens-before 重写了可见性:volatile 的写与后续的读之间建立跨线程的因果,周围的重排序被禁止;构造期间引用不外逃的对象,其 final 字段对所有线程立即可见,安全发布从此不需要同步;未正确同步的程序行为受限,再坏也坏不出凭空造值。双重检查锁定是最著名的受益者:旧模型下即使加了同步也可能拿到半初始化的单例,新模型里给实例加上 volatile,发布与读取之间就有了契约。旧模型的死法值得解剖:构造一个对象分三步,分配内存、初始化字段、把引用赋值给变量;重排序把第三步挪到第二步之前,引用先发布,字段还是零值;另一个线程此时读到非空引用,拿到的就是半成品。死法的荒谬在于三步在单线程视角完全正确,错的是跨线程的可见顺序;单线程的正确保证不了多线程的正确,这就是内存模型存在的全部理由。单线程的语义底线叫 as-if-serial:不管怎么重排,单线程看到的结果必须与按序执行一致;编译器与 CPU 的优化自由,以这条底线为界。底线之内随便排,底线之外一步都不能动;happens-before 负责的,正是底线之外的跨线程部分。
class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
Singleton t = instance;
if (t == null) {
synchronized (Singleton.class) {
t = instance;
if (t == null) {
t = new Singleton();
instance = t;
}
}
}
return t;
}
}
volatile 的实例引用是整段正确性的支点:构造写入与实例发布之间的顺序被钉死,读取的线程要么看到空,要么看到完整成品,再没有第三种状态。局部变量的引入是顺手的手艺:减少对 volatile 的重复读取,慢路径只走一次。volatile 自身的读写代价并不对称:读只是禁止重排,开销接近普通读;写之后必须跟一道最重的写读屏障,把前面的普通写一并推到其他核心可见,开销高出一截。读写不对称的含义是,能用读解决的问题不要用写轮询;自旋等待标志位用读循环,状态翻转的那一下才用写——税率不同的操作,要配不同的用法。final 的安全发布是另一块基石:构造期间引用不外逃的对象,final 字段的值对所有线程立即可见,不需要任何同步。不可变对象因此成了并发世界的安全岛:岛上的东西写死之后人人可读,读岛不需要签证;岛的边界就是构造函数的出口,this 逃出去之前,一切都还来得及。函数式语言对不可变的偏爱,在这里找到了硬件层的回声。
C++11 沿着同一方向走了更远:内存序做成可逐操作指定的档位,从最宽松的 relaxed 到最严格的顺序一致,release 写与 acquire 读配对即建立跨线程同步;保证是 DRF-SC——没有数据竞争的程序,表现得如同顺序一致,正确同步的程序不会被模型坑,竞争的程序后果自负。档位越多,心智负担越重;C++ 把选择的权力交出去,收的是学习者的学费。Java 与 C++ 的对照值得摆成表格:Java 的 volatile 是中间强度的存在,读写都有明确语义;C++ 没有对应的中间档,要么 relaxed 的弱,要么 acquire-release 的配对;Java 的 final 有初始化安全保证,C++ 的 const 没有跨线程发布语义。中间档的有无,是两种设计哲学的分野:Java 替普通开发者预置了够用的档位,C++ 把档位表整个摊开,让每个人自己选。屏障是契约在硬件层的兑现:读读、读写、写写、写读四类,x86 靠强模型省掉多数,只在最重的写读处 fence,ARM 则需显式屏障。凭空造值的禁令是底线中的底线:再怎么优化,读出来的值必须是在某处被写过的;一个从未被赋值的数凭空出现,意味着因果链断了,调试将无从谈起。禁令守住的是因果的尊严:乱序可以打乱到达的先后,不可以捏造到达的内容。伪共享是缓存行的连带伤害,细节留给本卷的并行代价章,本章只记一笔:正确性之外,性能另有战场。
1978 年的一封信:CSP
1978 年,托尼·霍尔(Tony Hoare)发表通信顺序进程理论:并发交互的形式语言,进程代数家族的一员,基于通道的消息传递。它不讨论共享内存怎么写对,只规定进程之间如何交谈:各算各的,算完把结果塞进通道,对方从通道里取。交谈的拓扑代替锁的顺序,成为正确性的新载体。消息派的代价同样实在:数据过通道要拷贝,大对象传来传去,拷贝的开销吃掉并发的收益;拓扑写死之后,动态变化的协作不好表达,临时加一路通信要改全图;请求应答多一轮往返,延迟比直接读内存高一个数量级。共享派的竞态难复现,消息派的死锁易复现:通道空等对空等,环形等待画出来一目了然,调试器跟一遍就现形——错得明白,是消息派最大的体贴。工业的常态是混合:模块内部用锁管共享状态,模块之间用通道传消息;对外拓扑,对内互斥,各取所长。混合的边界就是团队的边界:边界以内,一个人说了算,锁的顺序记得住;边界以外,多人协作,通道的契约看得见。康威定律在这里提前显形:通信结构映照组织结构——那是本卷微服务章的主题,此处只记一笔,跨组织协作的摩擦,迟早要从内存烧到架构。这套理论直接影响了 Occam 语言的设计,又在三十年后经 Go 的 channel 发扬光大——第 048 章写过它的管道与协程,此处不再重复机制。并行宇宙的另一支是第 042 章的 Erlang:Actor 模型让互不共享的进程靠消息协作,崩溃了由监督树重启;本章的共享内存派与之恰成对照:一个相信隔离,一个死磕共享;一个用重启换容错,一个用证明换正确。两派的分野不在语法,在对人性的判断:人到底是管不住共享,还是不该共享。
等待的形状:从回调到 async
并发的另一半难题不是写,而是等。异步操作靠回调表达的时候,流程每深一层,嵌套就多一层:先查用户,再查订单,再查库存,再下单,四层回调层层缩进,错误处理在每一层各写一遍,取消逻辑散落在层层闭包里;读代码像剥洋葱,改一处要同时改对四层的缩进与四个错误分支。回调地狱不是风格问题,是状态分散问题:流程的完整意图被切碎在多个函数里,没有一个地方能看到全貌,人脑的工作记忆一次装不下整个流程,改错是注定的。2009 年,Node.js 把单线程事件循环加回调做成默认模型(前文写过它的排队哲学,此处不复述机制);回调写法的可读性危机,随后由 2012 年 C# 5.0 的 async 与 await 收编:等待写成顺序的语句,编译器生成的状态机接管回调的嵌套——第 047 章讲过这种收编,查询、异步、属性,收编的名单一直在变,收编的动作始终是同一个。2013 年到 2017 年,响应式流把事件包装成可组合的数据流,背压、合并、切换有了统一的词汇。背压是流式世界的新契约:生产者太快、消费者太慢,中间的队列会被撑爆;背压让消费者有说“慢点”的权力,生产者按需放缓,队列的长度从失控变成可调。没有背压的流是失控的卡车,有背压的流才是运输系统。四十年三次浪潮的口径正在成形:内核线程、事件循环、轻量调度,轮流坐庄,庄庄解决的是同一个问题——等待的时候,别占着线程。事件循环的边界同样清楚:计算密集的任务不适合它,一个死循环的计算会卡住整个循环,所有的等待都被连累;等的是输入输出,它是神,算的是矩阵,它是坑。饥饿是事件循环的慢性病:一个回调算得太久,后面的回调全在排队,延迟一路走高;解法是把长计算切碎,或者扔给线程池,循环只负责等。切碎的手艺就是协作式让出:算一段,主动交出执行权,让循环处理别人的等待,再回来接着算。让出的自觉,漏洞百出也比比皆是;自觉靠不住的地方,后来长出了抢占式调度——那是运行时的事,本章只记一笔:协作的尽头,是不再信任协作。等与算的分工,从事件循环普及的第一天就写好了:等的那一半交给循环,算的那一半另起线程池。
async 的本质值得钉死:阅读的形状是顺序的,执行的形状仍是事件驱动的。await 的那一行,线程没有睡,只是把后续的执行登记成回调后去干别的,数据抵达再回来继续。顺序是写给人看的,事件是留给机器的;翻译的手艺与内存模型同构,只是翻译的对象从“顺序”换成了“等待”。
账单与反对者
无锁的账单首先开给验证。无锁算法极易写错,错法又极难复现:百万次运行一次的交错,压测全过,上线翻车;正确性的信心只能来自形式化验证、内存模型分析工具与不眠不休的压力测试,小团队付不起这笔钱。验证难的根子是状态空间爆炸:两个线程的交错已经数不清,八个线程的交错是天文数字,测试覆盖的永远是冰山一角;可证明的无锁算法凤毛麟角,工业界的大多数无锁代码,信心来自“跑得够久没出事”。内存回收是第二笔:无锁结构里节点的生死无人看守,hazard 指针与 RCU 的实现复杂度常常超过数据结构本身,回收的正确性证明比算法还长。Linux 内核大规模使用 RCU 机制,读端零开销、写端等宽限期,是工程上最成功的延迟回收;但宽限期的判定、回调的编排,处处是细节,抄作业都容易抄错。内存模型的账单开给所有人:档位越多,误用越多,relaxed 写错一处,调试三个月;模型的心智负担从语言设计者转移到了每一个写并发代码的普通人头上。async 的账单开给生态:库要分同步异步两套写法,调用链一旦染上异步就全链变色,颜色的传染没有疫苗。调试的断裂更疼:顺序的阅读形状掩盖了事件的执行真相,堆栈在 await 处拦腰而断,跨回调的因果链无处可查;定位问题靠的是请求粒度的关联标识,把散落的日志按标识拼回去,拼图的人是工程师,图的碎片是机器撒的。取消是另一笔:长流程走到一半不要了,取消信号要沿着调用链一级级传,每一级都要问“我该停吗”;传丢一级,任务在后台接着跑,资源接着烧。取消的语义没有银弹,只有约定;约定越统一,漏传越少。
反对者的分量要正面称量。锁派的反驳在多数业务里成立:竞争不激烈的时候,锁的开销根本不是瓶颈,无锁的复杂度才是;正确性有保障的慢,胜过正确性存疑的快。保守顺序派的反驳在可维护性上成立:强内存模型心智负担小,写对的概率大,为了压榨最后一点性能把程序写成只有三个人能懂的样子,是拿组织的未来换眼前的数字。async 怀疑派的反驳在调试上成立:顺序的阅读形状掩盖了事件的执行真相,堆栈拦腰而断,问题定位回到石器时代。三派的共同点是替普通人说话:并发的正确不应该是少数架构师的黑魔法;任何把门槛抬到只有天才才够得着的方案,都是对工业的欠账。门槛的下降有三条路:课程把经验变成教材,工具把检查自动化,语言把正确写进默认。数据竞争检测工具能在测试期抓住交错中的非法访问, sanitizer 插桩的代价是跑得慢,慢的测试总比线上事故便宜;锁的顺序检查、死锁检测,都在把“记住”变成“查出”。工具演进的方向与翻译史一致:人记不住的,交给机器查。这句批评的分量,第 055 章的并行代价会给出完整的回声。
一道契约,两种上限
回到卷五的主导约束:超大规模软件系统维护的人脑认知上限与跨组织协作的摩擦成本。并发状态管理的全部历史,就是在这两条上限之间修路。CAS 把交错翻译成重试:人不用再记住所有可能的执行交错,只需要写对“失败就重来”;锁是第零号翻译,互斥把交错翻译成排队,代价是并行退化成串行;内存模型把乱序翻译成因果:人不用再记住三层重排,只需要守住 happens-before 的几条规则;CSP 把共享翻译成拓扑:人不用再记住锁的顺序,只需要画对管道;async 把回调翻译成顺序:人不用再记住嵌套,只需要按顺序书写。四个翻译共用一个方向:把机器擅长的留给机器,把人必须理解的压缩到工作记忆装得下的几条规则里。每一次翻译都是一次减负,每一次减负都由另一方买单:重试烧 CPU,屏障烧性能,管道烧表达力,状态机烧调试——认知上限的账,从来只是换了个债权人。翻译的边界同样要钉死:内存模型保证可见与有序,不保证业务逻辑对;happens-before 管的是“看到的顺序”,不管“看到的值合不合理”;一个在因果上完美的程序,照样可以在业务上错得离谱。翻译解决的是机器与人的语言差,解决不了人与事的理解差;后者是测试、评审与领域知识的地盘,翻译的手伸不到那里。减负的另一面是依赖:规则越少,人越离不开规则;守惯 happens-before 的程序员,换一门没有内存模型的语言立刻不会写并发。翻译养活了人,也驯化了人;驯化的结果是离开翻译寸步难行。这不是批评,是所有抽象的共性:电梯养活了高层,也驯化了爬楼的能力。
协作摩擦的账记在标准的页码里。内存模型之所以必须是标准委员会的产物,是因为乱序的真相分散在每一家芯片厂商、每一台编译器手里:x86 的强保证、ARM 的弱保证、编译器的优化策略,没有一份跨组织的契约,程序员就要为每对组合各写一遍并发。委员会的谈判桌上坐着两派人:芯片厂商要弱保证,弱模型的硬件跑得快、做得便宜;语言实现者要强保证,强模型的程序好写、不易错。JSR-133 与 C++11 的每一个条款都是这两派拉锯的结果:happens-before 的严格程度、屏障的插入位置、优化的允许范围,字字都是妥协。妥协的文本一旦发布,就成了所有厂商共同遵守的界面:厂商按契约实现重排与屏障,程序员按契约书写同步,并发代码第一次可以在组织之间流通。标准的页码越厚,流通的成本越低;页码本身,就是协作摩擦的度量。翻译史的时间线可以收成一行:1978 年理论写出消息的形状,2000 年委员会开始重订内存的契约,2004 年契约随新版本落地,2011 年另一门语言跟进自己的内存模型,2012 年等待被收编成顺序的写法。三十四年,四次翻译,一次比一次离普通人更近;下一次翻译的对象,很可能是连翻译本身都不再需要的写法——那是后话,本章只负责把已经发生的讲清楚,讲清楚本身就是减负,而且是最便宜的那种减负,人人付得起,处处用得上,年年都有效。CSP 的命运同样说明协作的重量:理论 1978 年就已完备,工业兑现等了三十年,等的是 Go 的运行时、Erlang 的生态、芯片多核化的压力——思想不缺正确,缺的是兑现它的组织条件。async 的三浪潮也是协作史:回调、语法糖、响应式流,每一次换代都是社区先长出非正式共识,标准随后追认;顺序永远是先有事实写法,后有法条。
本章的断言是:并发正确性的全部历史,是把机器的真实乱序翻译成人类可理解的因果的翻译史——CAS 翻译交错,内存模型翻译顺序,CSP 与 async 翻译等待;翻译每精确一分,机器的优化自由就多一分,人的理解负担就少一分。这个断言可以被反驳:如果未来出现一门主流语言,既不要显式同步原语也不是消息传递,却让普通开发者写出大规模正确的并发程序,那么翻译论就是错的,正确性另有更便宜的来源,乱序与因果之间还藏着一条没人走过的近路。
第 054 章 1958—2020:内存回收与生命周期的四种解法
凌晨三点,监控曲线又抬头了。服务的内存占用随时间单调上涨,空闲时也不回落,重启就好,三天复发。排查的剧本每次都一样:堆快照对比,找出只增不减的类型,顺着引用链往回走,走到某处发现一个早该释放的缓存——写它的人三年前离职,注释里没写谁负责释放;内存调试工具跑出的泄漏调用栈有几十层,层层都是“可能”,没有一层写着“就是”。另一类事故更干脆:两次释放同一块内存,堆管理结构被踩坏,程序当场崩溃,连告别都没有;或者指针指向的内存已被释放,读出来的数据是对的,写进去的那一刻全错——悬垂的指针从不提前打招呼,招呼打出来的时候,数据已经坏了。内存的生死簿上只有一句话:谁分配,谁释放;什么时候死,谁说了算。六十年里,这句话被翻译成四种解法:人记住、数数、顺藤摸瓜、编译期归属。本章是四种解法的完整谱系。
第一种解法:人记住一切
手动管理的规则只有一条:每个 malloc 配一个 free。规则的反面是四种死法:分配了没释放,内存泄漏,占用单调上涨直到耗尽;释放了还在用,悬垂指针,读写的是别人的内存;释放了两次,双重释放,堆管理结构损坏直接崩溃;写出边界,缓冲区溢出,覆盖的是相邻的数据甚至返回地址。好习惯只有两条:free 之后立即置空,realloc 用临时指针接收再判空——前者杀死悬垂,后者保住原内存。realloc 的陷阱值得单列:它可能搬家,返回的新地址与原地址不同;直接把返回值赋给原指针,失败返回空的那一刻,原指针丢了,原内存漏了——一次失败,两处事故。正确姿势是临时指针接住,判空,成功才交接;交接的动作虽小,省的是丢指针的大祸。越界是第四种死法里最毒的一种:写出分配的边界,覆盖的是相邻的数据;盖掉的是普通变量,程序算错;盖掉的是栈上的返回地址,控制流就被劫持——缓冲区溢出从 bug 变成漏洞,只差一个精心构造的输入。边界检查的缺席是手动管理的原罪:快是真快,错也是真错。异常路径是重灾区:分配与释放之间的代码抛了异常,释放语句永远执行不到;漏的每一次,都是泄漏的一次。异常安全的解法是把释放绑在作用域上:离开作用域自动执行,抛不抛异常都一样——这就是资源获取即初始化的思想,手动管理的第一个补丁,补的是“人会忘”的洞。栈的事故是另一面:递归没有底,调用层层压栈,栈空间先见底;大数组搁在栈上,一次声明就撑爆帧;栈溢出的崩溃干脆利落,不给调试留面子。野指针比悬垂更早:变量没初始化,值是随机的,指到哪里算哪里;初始化为零的习惯,杀的就是这种随机。工具链的兜底各有分工:泄漏检测跑出调用栈,越界检测在非法访问的第一现场报警,快照对比找出只增不减的类型;工具跑得越慢,查得越准,慢与准的权衡,写在每一次深夜排查的咖啡杯上。
int *p = malloc(n * sizeof(int));
int *tmp = realloc(p, 2 * n * sizeof(int));
if (tmp != NULL) { p = tmp; } /* 失败则原内存仍有效 */
free(p);
p = NULL; /* 悬垂到此为止 */
四种死法的病根是同一个:所有权与生命周期的错配。谁负责分配,谁负责释放——模块 A 分配、模块 B 使用、指望模块 C 释放,契约没写进代码,责任就没人认领;内存从何时有效、到何时结束,边界含糊,错误就从含糊里长出来。栈与堆的分野是理解错配的起点:栈由编译器自动打理,函数进入分配、退出释放,快而守规矩,代价是空间小、生命期逃不出作用域;堆是自由存储,由程序员手动管理,空间大、生命期自定,代价是每一笔账都要自己记。把本该放堆里的长寿数据搁在栈上,函数返回即悬垂;把本该早死的数据忘在堆里,泄漏就从这一刻开始计时。分区用错,错配的一半已经写好。大型项目的指针传递路径经手多人,释放的责任在交接中丢失;排查工具只能事后诸葛:Valgrind 跑出泄漏的调用栈,插桩工具在退出时打印未配对的分配,快照对比找出只增不减的类型。工具能定位,定位不了责任——责任是组织问题,不是技术问题。双重释放踩坏的是堆管理结构:分配器在每块内存的头尾记着账,第二次释放把账本改成乱码,之后的分配与释放在乱账上进行,崩溃只是时间问题;崩溃的现场离病根隔着千山万水,排查从 core 文件开始,一步步倒着走。泄漏的慢性在于隐身:服务跑着跑着变慢,容器以内存超限为由杀掉进程,重启又好;泄漏的速度越慢,定位越难,快漏一眼看见,慢漏要攒几个月的快照对比。慢漏是组织级的慢性病,治它要的不是工具,是把内存曲线纳入日常巡检的制度。多线程把难度再翻一倍:线程甲正解引用,线程乙咔嚓释放,甲一头栽进未定义行为;老派的解法是加锁,访问前上锁改完解锁,锁的代价上一章已经算过。智能指针的原子拷贝是轻量答案:复制一份共享所有权再慢慢用,底层的对象在最后一份拷贝消失前不会死——数数的思想,已经在这里探头。
第二种解法:数数
引用计数的规则直观:每个对象配一个计数,添一处引用加一,去一处引用减一,归零即释放。释放的时机是确定的——计数到零的那一刻,没有延迟,没有后台线程,析构准时执行;确定性是实时系统与资源管理的刚需,文件句柄、锁、套接字,关得晚一秒都是事故。独占所有权是数数的极简版:同一时刻只有一个持有者,转移只能移动不能拷贝,开销与裸指针相当;工厂函数返回的对象、容器的元素、类的独有成员,都是独占的形状——独占的含义是责任唯一,释放的时候不用开会。共享所有权是完整版:多个持有者共治,控制块里记着计数与删除器,计数归零删对象;控制块本身是额外的一块内存,存着强计数、弱计数与自定义的删除逻辑,体量约等于两个指针。自定义删除器是共享的后门:管理的可以不是 new 出来的内存,文件句柄、套接字、锁,关闭的动作写进删除器,归零的那一刻自动执行——数数的对象从内存扩展到一切资源。打开的文件没关,计数归零时自动关闭;互斥量没放,归零时自动释放;资源的生死与指针的生死同进退,退的是同一步。后门用好了是通用,用不好是混乱:删除器里再抛异常,析构的路上又多一个坑;自定义的动作越重,归零的时刻越不可预测。确定性的承诺只保释放的时机,不保释放的代价;代价写在删除器里,读的人要自己翻。计数的增减是原子的,多线程下计数本身不会错;原子操作的代价是缓存行在核心之间弹跳,高频拷贝的场景下,弹跳的开销积少成多。但原子管的是计数,不管对象——对象的线程安全,还得另想办法;把计数安全当成对象安全,是共享指针最常见的误用。
let r;
{
let x = 5;
r = &x; /* 编译错误:借用的值活得不够久 */
}
println!("{}", r);
数数的死穴是循环引用。两个对象互相强引用,计数永远归不了零,外部删光了引用,它们还在内存里互相取暖;泄漏换了个形状,从“忘了释放”变成“放不掉”。最简的循环只要两行:甲的成员指着乙,乙的成员指着甲;外部的变量删了,甲乙的计数各剩其一,谁也归不了零,谁也走不了。动态语言的用户对此最有体感:两个互相引用的对象,名字都删了,内存还占着;解释器的兜底是自带的分代回收,定期出来巡一圈,把循环的死结解开。兜底的存在说明数数需要上级:纯计数管不了环,环要靠追踪来收——第二种解法与第三种解法在这里握手,握的是同一只内存的手。打破循环要靠弱引用:不拥有、只旁观,不增加计数,循环链上至少有一环是弱的,计数才能归零。弱引用是数数体系的补丁,补丁的存在证明数数不是完备的——完备的方案不需要补丁。认亲之前先问一句“谁拥有谁”,画得出所有权树的用强引用,画出环的地方换弱引用;问的习惯本身,就是所有权意识的萌芽。多线程的误用值得单列:计数的原子只保计数,两个线程同时读写对象本身,数据照样竞争;以为用了共享指针就线程安全,是把半张门票当成全票。门票的另一半是对象内部的同步:互斥、原子成员、不可变设计,缺一不可。数数管的是生死,不管的是对错;生死分明,对错还得另算。计数的另一笔税是开销:控制块的额外内存、每次拷贝的原子操作,高频共享的场景下积少成多;税是明码标价的,比泄漏的暗税便宜,比零开销贵。数数适合的形状是清晰的:所有权树是树不是网,引用有向无环;形状一乱,数的账就算不清。
第三种解法:顺藤摸瓜
追踪式回收换了思路:不记每个对象的账,只定期从根出发,把能到达的都留下,到达不了的都是垃圾。思想的首创属于 1960 年的 Lisp,麦卡锡的标记清除是这一谱系的源头,此处只记一笔,细节是第三卷的故事。根是全局变量、栈上的引用、寄存器里的值——程序活着的每一处牵挂;顺藤是沿着引用关系走完全图,走到的活着,走不到的死。根的枚举本身就是一门手艺:栈上散落的引用要一张张认领,寄存器里的值要停下来看,认领的清单叫根集合,漏掉一个,活物就被当成垃圾。停下世界就是为了认领:线程暂停在安全点,栈的状态凝固,枚举才不会认错人;停顿的长度,起步就写在枚举的成本里。三色标记是遍历的工程形态:白色是从未访问,灰色是访问过但邻居没看完,黑色是连邻居都看完了;从根开始染灰,灰的邻居染灰,自己染黑,灰集合空了就结束,剩下的白色全部回收。并发标记的麻烦是应用线程与标记线程赛跑:黑色的对象忽然挂上白色的新引用,标记已经走过,不会回头,漏标就是把活物当垃圾;写屏障是裁判——引用被修改的那一刻记一笔,标记回头补看,漏的一个都跑不掉。屏障的代价是每次引用写入都多一次记录,并发的正确拿运行时的每一次写操作缴税;税缴了,漏标才绝迹。屏障的记录策略有两派:记新增的,新增的引用重点复查;记删掉的,删掉的路径整体重看。两派的正确性都成立,代价分摊不同:新增派平时记录多,回收时复查少;删除派平时记录少,回收时重看多。派别的选择写在收集器的基因里,基因不同,税的缴法不同。全量回收的触发条件是水位:老年代满了,晋升失败了,元数据区撑爆了,水位一到,全堆停顿;水位的监控是运维的日常,调优的目标就是让水位涨得慢、让全量来得晚。水位与停顿的跷跷板,是追踪派永远的功课。安全点的设计是停顿的另一半:线程不能在任意指令处停下,只能停在事先约好的位置;约好的位置散布在方法的调用处与循环的回边,密度决定了停下的最坏延迟。停下的动作是轮询:线程跑到安全点,看一眼要不要停,要停就地等待;看一眼的开销分摊到每一次经过,积少成多也是税。碎片是清除算法的慢性病:空闲块越切越碎,大对象要连续的大块,满地碎块拼不出一间整房;整理的搬家与复制的对半,都是治碎片的药,药费分别是拷贝与半壁内存。全量回收的恐惧悬在每个运维头上:堆越大,扫得越久,业务停得越久;恐惧的解法只有分代与并发,把“一次停很久”拆成“多次停很短”,拆的艺术就是收集器的全部身价。
三种清扫方式各有各的账:标记清除不清场,碎片越积越多,大对象迟早没地方住;标记整理搬家,把活物挪到一端,边界之外一次清空,搬家的拷贝是税;复制收集最激进,内存对半分,只用一半,回收时把活物拷到另一半,原半整个扔掉——税是半壁内存,赚的是回收的干脆,垃圾占比越高越划算。分代假说猜中的是对象的寿命:新生代朝生暮死,高频小回收;老年代难消难亡,低频大回收;每次小回收存活的晋升一级,熬过几轮的就是老臣。跨代引用的比例极小,不必为少数的跨代扫描整个老年代;卡表记下老年代里指向新生代的脏页,回收只看卡,不管全堆。卡表的粒度是折中:页划得太大,脏页里多是无关对象,白扫;页划得太小,卡表本身占内存,核对的次数也多。粒度的取舍是实践磨出来的:脏的代价与查的代价握手言和的地方,就是卡页的大小。假说的本质是把统计规律写进算法:大多数对象死得早,回收就该围着早死的转;猜对了是性能,猜错了是额外的一轮全扫描。晋升的门槛是年龄:熬过一次小回收记一岁,岁数攒够才进老年代;朝生暮死的新生儿死在摇篮里,老成持重的才配进长老院。年龄的计数器存在对象头里,每活一轮加一;计数器的位数有限,封顶即晋升——规则简单,执行一视同仁。大对象走绿色通道:超过阈值的庞然大物不进新生代,直接住进老年代;搬来搬去的拷贝对大块头太贵,长痛不如短痛,一步到位反而便宜。绿色通道的阈值是调参的重地:设高了,新生代被大块头挤爆;设低了,老年代过早填满;阈值的位置,写着业务的对象画像。猜错的代价不大:多扫一遍,无非慢一点;猜对的收益极大:九成垃圾一次带走。赌局的赔率写在对象的寿命分布里,分布站在假说这边。
停顿是追踪派的终身战争。早期的回收要停下整个世界:线程全部暂停,堆从头扫到尾,扫完再开工;堆越大,停顿越长,百 GB 的堆能停上秒级。并发标记把大部分工作搬到与应用并行,停顿只剩最初与收尾的两个短暂停;G1 把堆切成小块,并发周期里挑垃圾最多的块先收;新一代收集器把标记位藏进 64 位指针的高位,指针自带颜色,搬迁与标记并发进行,停顿压到亚毫秒级。谱系从串行走到并行再走到并发,方向只有一个:应用线程停得越短越好。分区收集是并发的搭档:堆切成大小相近的小块,回收以块为单位,垃圾最多的块先收;整堆停顿拆成小块的分数次暂停,最坏情况从“停全堆”变成“停一块”。指针自带颜色是新一代的绝活:地址的高位藏着标记状态,读屏障在解引用时顺手核对颜色,搬迁中的对象自动跟上新地址;标记、搬迁、应用三者同行,停顿只剩翻页的两次短暂停。代价同样清楚:并发的正确性要屏障保证,指针的编码要硬件配合,吞吐为延迟让路——延迟敏感的业务选新贵,吞吐优先的离线任务守旧版;没有最好的收集器,只有最配的账单。选型的口诀只有一句:先量停顿的预算,再数堆的大小,最后才看收集器的名字。
四种解法:记忆搬到哪里
┌────────────┬──────────────┬──────────────┬──────────────┐
│ 人记住一切 │ 数数 │ 顺藤摸瓜 │ 编译期归属 │
│ malloc/free │ 引用计数 │ 追踪 GC │ Rust 归属 │
│ 记忆在人脑 │ 记忆在计数器 │ 记忆在运行时 │ 记忆在编译器 │
│ 忘=泄漏 │ 环=死锁 │ 停顿=税 │ 学费=税 │
│ 错=崩溃 │ 拷贝=开销 │ 碎片=税 │ 严苛=安全 │
└────────────┴──────────────┴──────────────┴──────────────┘
方向:人的负担递减,机器/编译器的负担递增
第四种解法:编译期归属
Rust 把账记在编译时。规则只有三条:每个值有唯一所有者,所有权转移后原变量失效,所有者离开作用域值自动释放;借用要么单可变独占,要么多不可变共享,两者不可共存;引用活得不能比数据久,短命的数据不许被长命的引用指着。移动的语义值得多看一眼:堆上的字符串赋值给新变量,旧变量即刻失效,不存在两个主人;失效不是运行时检查出来的,是编译器在赋值的那一行就划掉旧名字。此后任何对旧名字的使用都是编译错误,错误的信息指着赋值的行——错的根子找得到,找得到就改得掉。栈上的整数则相反:赋值即复制,新旧两个都能用;复制的便宜来自栈,堆的昂贵来自分配;编译器按存储的位置自动选择语义,开发者不需要背两套规则。借用的冲突有最日常的形状:同一作用域里,一边拿着可变借用改数据,一边还想用旧的不可变借用读数据——编译器拦下,理由是读写不能同席;改完再读,或者读完再改,顺序排好就放行。函数签名里的生命周期最说明问题:两个输入引用、一个输出引用,输出活多久,签名里必须写清——输出不能比两个输入中短命的那个活得更久;写不清的签名,编译器拒绝,拒绝的理由是调用者有权知道借来的东西能用多久。签名是契约,契约里必须有寿命条款。常驻内存的引用是寿命的特例:字符串字面量从程序启动活到结束,它的借用永远有效,标注里给它一个特殊的名字;特殊的背后是常识:活得最久的数据,借多久都安全。特例的存在让规则完整:有一般的比较,有特殊的豁免,豁免写在明处,不在暗处。第 048 章写过所有权的机制,此处聚焦生命周期的视角:编译器给每次借用推断有效区间,区间的比较在运行前完成;悬垂的引用连编译都过不了,报错的编号以 E0597 开头。标注是描述性的:开发者写的生命周期符号只是在帮编译器消除歧义,改不了变量真正的寿命;寿命是作用域定的,符号是给检查器看的。释放的顺序同样写死:同一作用域的多个值,按声明的逆序释放,后生的先走;逆序的理由是依赖的方向——后声明的更可能依赖先声明的,先拆上层,再拆地基。顺序的确定意味着行为的可预测:读代码能推出释放的次序,次序错了编译器会说;可预测是编译期归属的另一面,另一面朝向所有的自动管理。unsafe 是逃逸舱:裸指针、外部函数、可变静态变量,括号里面的安全编译器不管,签名的人负责;但借用检查的大门并没有关,逃逸的是部分检查,不是全部。
四种解法排成一列,税目一目了然。手动管理税在人:记住一切,忘了就崩,税率是事故;引用计数税在运行时:控制块、原子操作、循环补丁,税率是开销;追踪回收税在停顿与吞吐:暂停、屏障、碎片,税率是延迟;编译期归属税在学费:重学内存范式、与编译器对抗、编译等待,税率是时间。四种税没有一种能逃,逃掉的税都变成了事故;选解法就是选税种,看的是业务最付不起哪一种。嵌入式与实时系统付不起停顿,选手动或计数;大规模服务付不起事故,选追踪;错不起的基础设施付不起运行时错误,选编译期。税种与主场一一对应,对应不上的选型都是浪费。
账单与反对者
手动派的辩护首先值得听:确定性是刚需的场景里,GC 的停顿是不可接受的——毫秒级的卡顿在交易、控制、音视频里都是事故;嵌入式设备的内存按 KB 计,运行时的额外开销装不下;RAII 把资源的生死绑在作用域上,离开即释放,确定性不输手动,还不用记账。作用域是自动记账的妙处:花括号开,资源生;花括号合,资源死;生死与代码块同进退,异常来了也不改。手动的自由与自动的省心,在这里握手:性能敏感的部分留给手,记账的部分交给括号。反对追踪的理由不是怀旧,是算术:停顿的税在某些账本上贵过事故的税。引用计数派的辩护同样实在:释放时机确定,没有后台线程的不可预测;循环之外的形状里,它是最便宜的自动方案;弱引用补上循环缺口之后,日常的泄漏十去八九。数数的税是明税,明税好过暗税——这是计数派的全部底气。
追踪派内部的战争打得最久:吞吐派要回收得快,延迟派要停得短,两派的收集器互相看不上;调优的黑魔法只有少数人会,GC 日志的解读、代际比例的调整、屏障开销的权衡,配错一个参数,性能倒退一半。黑魔法的另一面是知识的垄断:调优的经验装在几个人的脑子里,人一走,参数就成了天书;组织为天书支付的,是每一次版本升级时的重新试错。黑魔法重现了前文的批评:正确与性能成了少数架构师的专属,普通人只配用默认。默认的保守是设计者的善意:宁可慢一点,不能错一分;善意的代价是天花板,能摸到天花板的人,永远是少数。Rust 派的账单开在入门处:学习曲线陡峭,生命周期标注劝退新人,编译时间漫长;小团队为它支付的学费,回收期按年计。愿意付的买的是确定性,不愿付的自有它的道理:错误代价不够大的业务,不值得为证明缴税。四派的批评者有一个共同点:替具体场景说话,不替主义说话;主义是免费的,场景是要付税的。布道的成本是隐性的账:新解法进组织,老成员要培训,新成员要考试,代码评审要加新条款;推行的阻力不在技术,在习惯——习惯是过去的税单装订成的,撕掉一页要疼一下。疼过之后,新的习惯长出来,税单换一本继续记;组织的学习曲线,与个人的学习曲线同构,只是更长、更贵,也更值得——省下的每一次深夜告警,都是这笔学费的利息;利息按年结算,越老越值钱,年年都有分红。
归属即记忆
回到卷五的主导约束:超大规模软件系统维护的人脑认知上限与跨组织协作的摩擦成本。内存回收的四种解法,是把“记住释放”这件事从人脑搬出去的四次搬家。手动管理要求人记住一切:每一块内存的所有者与死期,装在程序员的脑子里,脑子装不下就泄漏;引用计数要求人记住形状:所有权是树不是网,循环出现就死锁,形状的合法性装在设计里;追踪回收要求人记住调优:代际、屏障、停顿目标,参数的含义装在运维手册里;编译期归属要求人记住规则:所有权三条、借用两态、生命周期的包含关系,规则装在类型系统里,违反就编译不过。四次搬家,人的负担一次比一次轻,负担的目的地一次比一次贵:从免费的人脑,到廉价的计数器,到昂贵的运行时,到最贵的编译器。贵有贵的道理:越贵的搬家,事故越少;事故的减少值多少钱,搬家就值多少钱。
协作的摩擦记在交接处。内存的生死是跨模块的契约:谁分配谁释放,契约没写进代码,责任就在交接中丢失;库的接口是协作的界面,返回的指针归谁管,文档里必须有一句,否则调用者与实现者互相等对方动手。文档的一句抵不上类型的一句:注释会过期,签名不会;把归属写进类型,编译器就替组织记住了这笔账。外部函数的边界是摩擦的重灾区:两种语言的内存模型不同,分配与释放不能跨边界混用,谁的地盘谁做主,过界的指针要办手续——Rust 的 unsafe 花括号就是手续大厅,手续办完,责任自负。手续的严格程度与信任成反比:越不信任,手续越多;手续的每一道,都是协作摩擦的刻度。默认收集器的选择是协作的另一面:语言发行版自带的默认,就是大多数人的选择;换收集器是组织级的决策,要压测、要评审、要值班手册更新。默认的保守是多数人的共识:不出错,慢一点;共识的代价是天花板,想摸天花板的人自己去换。换与不换之间,是组织对性能的态度;态度写进配置,配置跟着版本走。GC 的调优知识是组织的隐性资产:会调的人离职,参数就成了天书;天书的每一页,都是协作摩擦的欠条。内存管理从来不只是技术,是分工:分工的界面划在哪里,事故就长在哪里——界面划在人脑,事故叫泄漏;界面划在运行时,事故叫停顿;界面划在编译器,事故叫学费。界面没有免费的午餐,只有不同的账单。
本章的断言是:内存回收的四种解法,是把“记住释放”这件事从人脑搬到不同地方的四次搬家——数数搬到计数器,顺藤搬到运行时,归属搬到编译器;每搬一次,人的记忆负担少一分,机器或编译器的账多一笔;搬家的终点不是消灭记忆,是把记忆翻译成机器能执行的形状。六十年的搬家史可以收成一行:人先记住一切,记住不住了开始数数,数不清了顺藤去找,找到的代价太大就提前归属。搬家的方向只有一个:离人脑越来越远,离机器越来越近;远的代价是税,近的收益是安稳。税与安稳的汇率,六十年没变过:付得起的税,换得来睡得着的觉;睡不着的夜,迟早会把没付的税连本带利收回去,一分都不会少,谁都跑不掉。这个断言可以被反驳:如果未来出现一种主流方案,既不要计数、不要追踪、也不要编译期证明,却让普通开发者写出无泄漏无悬垂的大规模程序,那么搬家论就是错的,归属另有更便宜的载体,记忆与执行之间还藏着一条没人走过的近路。
第 055 章 并行编程的代价:为什么它没有变得像串行一样简单
加一行日志,崩溃就消失
Linux 内核 6.1.28 与 6.3.2 的更新日志里,躺着一条不太寻常的修复。英特尔(Intel)声卡的 SoundWire 驱动在参数切换时必定崩溃,在某些测试设备上百分之百复现;开发者随即撞上一个更不安的事实:只要在出事的那行代码前插入一句调试输出 dev_dbg(),或者一个几微秒的 usleep_range() 延时,崩溃就消失;删掉日志,或换一个编译器版本重新编译,死亡准时归来。修复提交的标题最终定为:不要在 prepare 回调里保存 hw_params。根因是驱动保存了一个生命周期不持久的指针——那句日志“治好”崩溃的全部原理,只是让时间慢了一点点。
这类缺陷在工程界有个现成的名字:海森堡 bug(Heisenbug),借自物理学家沃纳·海森堡(Werner Heisenberg)的测不准原理——观测行为本身改变被观测对象。多线程程序最擅长表演这种戏法:你加一行 print 想看看哪里出了问题,这句 print 微妙地改变了线程交错的时序,缺陷当场隐身;你打开调试器单步跟踪,内存布局随之改变,缺陷再次隐身;撤走全部观测手段,它又在生产环境里若无其事地回来。嵌入式工程师见到的版本更具物理质感:一行经串口发出的 printf,在 115200 波特率下每个字节要占掉约 86.8 微秒,打印 50 个字符足以把 CPU 阻塞 4.3 毫秒——对一个周期 1 毫秒的电机控制环,相当于失明四个控制周期。日志没有修复任何逻辑,它只是物理地改写了时间的形状。
布莱恩·克尼汉(Brian Kernighan)那句被反复引用的告诫——调试的难度是写代码的两倍,因为如果你写代码时用尽了全部聪明才智,你已经没有余力去调试它——在串行时代尚可当作修辞。放到并行世界,它成了字面意义上的工程判决:观测的工具本身是扰动源,复现的前提是先承认不可复现。Linux 内核邮件列表里沉淀着大量此类讨论,PIT 定时器初始化的案例尤为直白:写完寄存器立即读回校验,部分硬件来不及就绪便报错,中间插一行 printk,一切正常。那行日志没有修好任何东西,它只是把“太快”变成了“没那么快”。
工程界为此发展出一整套与不可复现性共存的纪律:日志从开发第一天就以统一的细粒度常开,避免出事后再临时插桩;失败用例在夜里循环执行数百次,保存每一次的完整日志,再从几百次通过里精准捞出竞态真正触发的那一次;线程级数据竞争检测工具把显式观测换成编译期插桩,把扰动的成本压到最低。每一种做法都在承认同一个前提:你无法逼近这个缺陷,只能布好网,等它自己撞上来。
串行世界并非没有难缠的错误,但串行的病与并行的病属于不同的属种。串行程序的错误藏在逻辑里,观测可以逼近它:断点、日志、二分排查,每一步都朝答案前进。并行程序的错误藏在时间的缝隙里,观测本身就在改变时间——调试器是扰动源,日志是扰动源,连编译器一次无关紧要的代码重排都可能把问题唤醒或压熄。这个差别指向本章的主角:并行编程五十年的工具狂飙没能把它变成像串行一样简单的手艺,原因不在 API 设计不够优雅,而在于串行的简单本就是一个被精心维护的幻觉——硬件用流水线、乱序执行与多级缓存合伙演出的顺序性幻觉;一旦幻觉破产,程序员必须直面的东西就会从硅片的每一层物理拓扑里涌出来。
主频曲线低头的那一年
2001 年 8 月,英特尔把量产处理器的时钟推过 2GHz。按此前数年的斜率外推,2005 年初本该出现 10GHz 的芯片——这个外推写在当年每一份产品路线图上。曲线在 2003 年低头了:主频增长由陡升转为平缓,多年后再没人严肃谈论 10GHz 的通用核心。挡路的不是工艺懈怠,是一组叠加的物理事实:散热逼近极限,功耗密度继续上升,晶体管的电流泄漏越来越严重。赫布·萨特(Herb Sutter)2005 年发表的文章《The Free Lunch Is Over》把这组事实推到整个软件业面前,标题里的“免费午餐”一词借自约翰·巴科斯(John Backus)1977 年的图灵奖演讲:过去几十年,程序员无需改动一行代码,来年更快的芯片就会自动让程序提速,性能像餐厅赠品一样按季送达。萨特在文中清点了硬件提频的三条传统路径——提高时钟频率、优化指令执行、加大缓存——并指出前两条已经穷尽,靠提频自动变快的时代结束了一年或者两年,业界只是刚刚意识到。
更值得记下的是萨特文中的另一层坦白:为了榨出每周期性能,芯片设计师早已越过语义的红线——流水线、分支预测、乱序执行这类优化,按原文的说法,是在冒着改变甚至破坏程序语义的风险推进;对写操作的任意重排因为后果不堪设想而在设计中被关闭,读重排的后果虽轻,同样足以让细究语义的人脊背发凉。三条提频路径里,唯一还能继续的只剩加大缓存。换言之,所谓串行的简单,是硬件用一层又一层的推测与重排换来的:机器内部早已天翻地覆,而契约保证程序员看到的秩序纹丝不动。萨特对那一代程序员的处境另有一段近乎残酷的白描:如果你的程序慢了,传统智慧安慰你,别担心,明天的处理器吞吐更大;好消息是处理器还会继续变强,坏消息是,增长的主方向不再通往你现成的程序。习惯了等待的程序员第一次被告知:性能不再从天而降,它必须被亲手写出来。
芯片厂的回应是把同一个晶体管预算从“更快的核”改投为“更多的核”。2004 年被处理器行业称作“多核之年”,当年的秋季处理器论坛把多核列为主题;2005 年,英特尔与超威半导体(AMD)先后把双核产品推向主流桌面。时钟停在了 3GHz 档位附近——2002 年就有 3GHz 的处理器,约二十年后,主流桌面 CPU 的主频仍在这一数值上下徘徊,只在 4GHz 附近触到实际的热墙。萨特的文章让并发这个原本冷僻的研究方向一夜之间站上产业议程的中央。在微软,工程师乔·达菲(Joe Duffy)后来回忆那个转折:2004 年英特尔与 AMD 相继告知业界摩尔定律放缓、功耗墙成形;萨特 2005 年的文章把并发推向狂热,因为如果不能让开发人员写出大规模并行的软件,或者不能显著降低写并行软件的门槛,微软与英特尔互利共生的商业模式都会遇到麻烦——处理器与软件靠对方的需求活着,“英特尔生产的,比尔都拿走了”的增长循环失去了它的第一环。
此后的十五年是一场工具的大扩张,密度罕见。共享内存侧,OpenMP 以编译制导的形式把并行写进 Fortran、C 与 C++;任务并行侧,麻省理工学院(MIT)血统的 Cilk、英特尔的 TBB 把调度器做进运行时;异构侧,NVIDIA 用 CUDA 把 GPU 暴露为通用计算设备;语言侧,Java 与 C++ 先后把线程、原子操作与内存可见性规则写进标准,脚本语言们则把异步与协程做成了默认修辞。每一件工具都兑现了自己的承诺,没有一件落空。但账本上有一栏始终没有动:能用这些工具写出高性能并行程序的人数,在程序员总人口中的比例,与工具革命之前相比几乎没有变化。工具像雨后春笋,黑魔法依旧是黑魔法。萨特在 2005 年就写下了这句诊断的前提——大多数程序员习惯于编写顺序执行的代码;十五年后,顺序执行的代码依旧占了绝大多数,多出来的核心大部分在空转。萨特在文末开出的药方同样具体:把任务分解为可以独立执行的单元,以消息传递或共享内存协调;语言与库必须补上线程、互斥量与原子操作的底座;更高层的替代品——Actor 模型、函数式不可变数据、软件事务内存——被寄予厚望。这份清单在此后的十五年里逐一落地,又逐一显出各自的边界;工具栏被填满了,门槛却没有降到让多数人写出高性能并行程序的程度。
两派论战:更高抽象,还是没有免费的并行
面对同一组事实,工程界分成两个立场,双方都不是稻草人。
“更高抽象终将解决”一派的论据,全部来自抽象屡战屡胜的履历。汇编让位于高级语言,机器码的寄存器分配被编译器接管;手工内存管理让位于垃圾回收,悬空指针与内存泄漏被运行时兜住;每一次都有人断言复杂度不可驯服,每一次抽象都兑现了。并行凭什么例外?OpenMP 给出了最轻的方案:在循环前加一行 #pragma omp parallel for,编译器自动切分数据、派生线程、插入同步;删掉这行指令,程序退回正确的串行版本——并行被做成了一件可以“事后追加”的事。Cilk 走得更远,它的三个关键字背后站着一条漂亮的性质:串行语义——忽略关键字,一个正确的 Cilk 程序就是一个正确的串行 C 程序;调试时先当串行程序调,运行时的工作窃取调度器自动均衡负载。Java 8 的并行流把这个逻辑包进了一行 parallelStream(),它与程序员的交易写得很清楚:你交出“不许在循环里改外部变量”的自由,库替你完成切分、调度与合并。更激进的方案也在路上——软件事务内存(STM)许诺用一个大写的 atomic 关键字把整段代码变成原子事务,锁、死锁、遗忘加锁,统统由运行时料理。这一派的历史直觉相当可靠:复杂性从未被消灭,但确实一次次被装进了更小的盒子里。
只是这套方案的接缝,往往要等推广到复杂场景才暴露。OpenMP 的编译制导对付规则循环得心应手,标准却自认不适合复杂的线程间同步与互斥,也根本管不到没有共享内存的集群——那里是消息传递接口的领地。Cilk 的工作窃取对大粒度任务近乎魔法,但任务细到只有几条指令时,派生与窃取本身的开销就会吞掉全部收益,实践者把经验线画在微秒级以上。至于编译器自动并行化,它在最讲道理的科学计算里也只吃得下最驯服的形状:高斯-赛德尔迭代里每一次分量更新都依赖上一步的结果,求解器像一列必须逐节检查的车厢,理论上就无法拆成并行的车厢。抽象可以把并行的写法变简单,却绕不开一个问题:问题本身允许被切开吗。
“没有免费的并行”一派的反击,来自一桩又一桩可以复现的翻车现场。最锋利的武器是一则被工程师反复讲述的实战记录:一个 18.6 秒的单线程程序,程序员满怀信心加上 #pragma omp parallel for,结果变成 26.3 秒——比不改还慢,而且结果出了错。事后拆解出三个原因,每一个都平淡得让人绝望:循环体粒度太细,线程创建与同步的开销吃掉了全部收益;循环里有共享写入,存在数据竞争,OpenMP 不报错,只交付一个不确定的结果;在 8 核 16 线程的机器上开了 16 个线程,超线程互相抢流水线。理论侧的武器更老:吉恩·阿姆达尔(Gene Amdahl)1967 年给出的定律早已封顶——程序中串行部分占比百分之十,无论堆多少处理器,加速上限就是十倍。20 世纪 80 年代中期,当单机集成上百甚至上千个处理器的机器问世时,这一定律正是怀疑者手中的标尺:那些机器能否在应用中真正发挥威力,当年是一个严肃的疑问。约翰·古斯塔夫森(John Gustafson)1988 年给出了著名的辩护:不要固定问题规模,去固定等待结果的时间——把问题做大,串行部分的比例自然被稀释,加速比随之打开。辩护在超算中心成立,却解不了普通程序员的账:他们的问题规模由业务定死,不会因为买了一台 64 核服务器就膨胀 64 倍。经验侧还补了刀:微软对 STM 投入数年,做了运行时、操作系统乃至硬件层面的原型,最终整体放弃——达菲事后总结,比让某种机制“能工作”更重要的,是鼓励良好的并发架构,而 STM 恰恰纵容了糟糕的架构。
决斗的结果没有赢家,但划出了一条此前无人标出的界线。正确性的那一半战场,抽象确实在推进:锁的正确用法可以被类型系统约束,事务内存可以消化死锁,串行语义可以保住可调试性——凡是“逻辑”可以裁决的问题,抽象最终都能接管。性能的那一半战场,抽象节节败退:那两个并行计数器的程序结果完全正确,逻辑层面无懈可击,可它就是比串行慢——因为它踩中了一条 64 字节的缓存行。并行的困难不在 API,在物理;而物理不接受封装。
值得把时间轴摆直看:从 20 世纪 80 年代中期上千个处理器的机器,到 2005 年后进入桌面与手机的多核,同样的机制问题在两个世代重复上演——加速比先陡后平,瓶颈从计算挪向通信,悲观定律与救赎定律轮番出场。1988 年古斯塔夫森为千核机器辩护时,反驳的武器是 1967 年的阿姆达尔定律;2005 年之后,桌上那台四核笔记本把同样的考卷发给了几百万业务程序员。两代考生之间隔着一整个产业规模的差距,考题一字未变。
硅片的四次撕咬
抽象退守到哪里,物理就从哪里咬穿。咬痕有四处,每一处都值得拆开看清楚,因为它们共同构成了一门手艺无法简化的地形图。
第一处咬痕叫伪共享(False Sharing)。现代处理器的缓存不按变量管理,按缓存行管理,x86 主流口径的缓存行是 64 字节;缓存一致性协议(如 MESI)的运作单位同样是“整行”。这意味着两个在逻辑上毫无关系的变量,只要在内存里恰好相邻,就会被硬件绑成一根绳上的蚂蚱:任何一方写入,都会让另一方所在核心里的整行副本作废。两个线程各写各的计数器,代码上找不出任何共享,硬件却在核心之间把这条缓存行踢来踢去,每次移交都是一次跨核一致性事务,耗掉数十到上百个时钟周期:
主存中相邻的两个计数器,同处一条 64 字节缓存行
┌──────────────────────────────────────────────────┐
│ 计数器 A(仅核心0写) | 计数器 B(仅核心1写) |
└──────────────────────────────────────────────────┘
▲ ▲
┌──────────┴─────────┐ ┌─────────┴──────────┐
│ 核心 0 的 L1 缓存 │ │ 核心 1 的 L1 缓存 │
└────────────────────┘ └────────────────────┘
时刻 t1 核心0 写 A → 该行归核心0 独占
时刻 t2 核心1 写 B → 一致性协议按“整行”移交所有权,
核心0 的副本作废
时刻 t3 核心0 再写 A → 整行又被抢回核心0
……
逻辑无关的两个变量,缓存行在两个核心间乒乓往复,
每一次往返都是一次跨核一致性事务。
修复办法听上去像个玩笑:在两个变量之间手工填进几十个无用的字节,把它们的地址隔到两条缓存行里去,或者干脆让每个线程把计数写进自己的私有副本,最后再合并。工程师社区里流传的一类事故报告有着相同的形状:服务延迟从 5 毫秒量级飙到 200 毫秒,CPU 利用率却低得反常,性能工具的缓存行分析最终指认两个热点计数器挤在同一条 64 字节缓存行上;补上填充之后,延迟回到基线。这类事故最令人不安的地方在于:程序在逻辑层面完全正确,所有抽象契约都得到履行,性能却在物理层面崩塌——而语言、库与教科书对这层物理只字未提。写惯了串行程序的工程师第一次被迫思考一个问题:我的变量,此刻住在哪个字节上。这个问题语言本身无法回答——类型系统里没有缓存行的位置,变量的物理布局由编译器的对齐决定、由链接器的排布决定、由内存分配器的策略决定,改一处声明顺序,相邻关系就变。防御性的填充与对齐因此成了多核时代系统代码里的常规噪音:它们不表达任何业务语义,唯一的用途是向硬件声明——这两个变量,别放一起。
第二处咬痕是内存的距离。串行时代的内存抽象是一整块均匀的数组,任意一个地址的访问代价相同;多路服务器的 NUMA(非统一内存访问)架构把这层假设整个掀翻。每个处理器插槽挂着各自的内存,访问本地内存约 80 纳秒量级,访问隔壁插槽的内存要走跨插槽互连,代价显著更高——“你的内存不是一整块”。到了 2010 年代,芯片封装内部的拓扑进一步细化:AMD 用小芯片(chiplet)拼装处理器,一颗物理 CPU 内部可以被固件划成两到四个 NUMA 节点,同一颗芯片里也分出了内存的远近。调度器把线程放到错误的节点上,数据分配在错误的内存侧,程序照常正确运行,性能却无声地打折。连页表都在支付通信税:一个核心改写了某页地址映射,必须向所有核心群发中断,让它们把各自地址转译缓冲里的对应条目作废——内核开发者把这组操作称作跨核协调税的大宗支出。操作系统为此提供了一整套亲和性接口,让程序员显式声明“这个线程只许用这半边内存”——均匀内存这个抽象消失了,取而代之的是一张距离表,程序员要自己背下来。
第三处咬痕在 GPU 上。NVIDIA 把上千个小核心组织成另一种极端:以 32 个线程为一个线程束(warp),整束共用一条指令流,锁步前进——单指令多线程(SIMT)。这个设计把吞吐推到了空前的高度,代价是把一个此前不存在的物理约束直接写进了编程模型:同一个线程束里的 32 个线程,最好走同一条分支。一旦代码里的 if 让束内线程分道扬镳——16 个走真分支、16 个走假分支——硬件别无选择,只能先串行执行真分支(16 个干活、16 个被屏蔽空转),再串行执行假分支。两路分歧,有效利用率掉到一半上下;最坏情况 32 个线程 32 条路径,线程束退化成单线程。CUDA 编程指南白纸黑字写明了这条行为,工程师们则用另一个数字记住它:32 路全分歧,利用率约百分之三。编译器提供谓词化作为止痛片——把分支改成掩码、两条路径都执行一遍——不消除代价,只是换一种姿势支付。AMD 的对应设计曾把分组定为 64 线程,后来也向 32 收拢。无论哪家,结论一致:想让 GPU 高效,数据必须按 32 个一组预先排好队,让同一束的线程落进同一分支。这是把物理布局当成交付物的编程——数据怎么摆在内存里,直接决定指令流在硅片上的命运。访存侧的同类规则更加精细:同一束的 32 个线程若访问连续地址,硬件把它合并成一次内存事务,带宽满载;若地址分散,同样的 32 次访问要拆成 32 个事务,带宽利用率跌到三十二分之一。再加上共享内存里多个线程同时争用同一存储体会被强制串行化的条款,GPU 的性能手册读起来更像一张地形图:哪里是悬崖,哪里是沼泽,一一标明,路线自己选。
第四处咬痕最为反讽,因为它本身就是抽象的产物。2009 年,萨姆·威廉姆斯(Sam Williams)等人在《美国计算机学会通讯》(CACM)上发表 Roofline 模型,用一张二维图同时容纳硬件的两条上限:横轴是算术强度——每搬运一字节内存做了多少次浮点运算;纵轴是可达性能。水平屋顶是峰值算力,斜屋顶是峰值带宽乘以算术强度,两者相夹,程序的性能天花板一目了然:
可达性能 (FLOP/s)
▲
│ ┌─────────────── 峰值算力(水平屋顶)
│ │
│ ╱ │
│ ╱ │ 斜屋顶: 峰值带宽 × 算术强度
│ ╱ │ (每字节访存能支撑的计算量)
│ ╱ ● 典型程序
│ ╱ │
│ ╱ │
└──┴────────┴─────────┴──────────▶ 算术强度 (FLOP/字节)
脊点
左区: 带宽受限 —— 加多少计算单元都没用,内存喂料速度封顶
右区: 算力受限 —— 计算单元的峰值封顶
它把“该优化访存还是该优化计算”从玄学变成了读图题,此后成了从超算到深度学习人人都挂墙上的性能地图。但值得盯着这张图多看一眼:图上有计算,有带宽,唯独没有同步,没有一致性事务,没有核心之间的通信等待——多核世界里真正烧钱的那些项目,一条都没画。最好的性能抽象也只画出了物理的一半;另外一半,被画图的人默认交还给了程序员的经验与直觉。后来者给这张图补出过集群尺度的版本,把跨节点的互连带宽也画成屋顶——补丁越打越多,恰好说明最初的抽象低估了通信的权重。
这些咬痕拼在一起,解释了“无锁”这类词的真实含义。拿最经典的场景——多线程共享一个栈顶指针——来说,教科书上的解法是原子比较交换(CAS)构成的乐观重试循环:
/* 无锁栈的入栈:一次 CAS 重试循环(机制示意) */
typedef struct node {
struct node *next;
void *value;
} node_t;
node_t *top __attribute__((aligned(64))); /* 栈顶独占一条缓存行,防伪共享 */
void push(void *v) {
node_t *n = malloc(sizeof(node_t));
n->value = v;
for (;;) {
node_t *old = top; /* 1. 取栈顶快照 */
n->next = old; /* 2. 新节点指向旧栈顶 */
/* 3. 原子核对并替换:若 top 仍是快照 old,写入 n;
若别的线程抢先改过 top,本次尝试作废,重来 */
if (compare_and_swap(&top, old, n) == old)
return; /* 成功 */
/* 失败:这一轮工作全部白做。“无锁”没有消灭竞争,
只是把“排队等待”换成了“乐观重试” */
}
}
注意第一行之后的那个对齐声明:为了不让栈顶指针和别的数据挤进同一条缓存行,实现者必须显式把它隔离开——一行看似无关的布局代码,挡住的是第一处咬痕。而这个“无锁”循环也没有真正绕开物理:竞争高企时,失败重试一波接一波,白做的功变成热量;写它的人还必须额外提防快照失效的种种边角,比如那个臭名昭著的 ABA 问题——栈顶从 A 变成 B 又变回 A,快照核对通过,内部结构早已面目全非。无锁不是没有代价的锁,它是把锁的代价换算成了重试、白工与验证成本之后的一种支付方式。
至此可以把海森堡 bug 的病理写全了。一句 printf 的扰动至少有三条物理通道:经串口逐字节发出时的微秒级阻塞,改变了线程交错的相对时序;日志代码改变了局部变量的内存布局,把原本相邻的变量挤进或挤出同一条缓存行;在内核这样的环境里,printk 附带的内存屏障语义甚至能把编译器与处理器悄悄重排过的访存顺序重新拉直——SoundWire 驱动那行“治好”崩溃的日志,走的就是这类通道。观测的盲区甚至蔓延到性能工具本身:x86 上,自旋锁的竞争表现为时钟周期暴涨、每周期指令数跌到 0.01,分析工具一眼可辨;ARM64 上,WFE 指令让空转的核心直接进入低功耗状态,性能计数器随之停摆,竞争干脆从监测数据里消失——硬件级的沉默。观测行为改变观测对象,这个机制与量子力学毫无关系,它只是物理事实对语义层层的直接入侵:在并行程序里,时间、距离与布局不再是可以忽略的实现细节,它们就是语义本身的一部分。
账单流向谁
抽象每宣称掩盖一分矛盾,就有一批人在它击穿的边界上排队结账,这笔账单在并行编程上至少分三联。
第一联寄给写运行时的人。Java 与 C++ 的标准委员会花了十余年把内存可见性的规则写成普通程序员可以引用的条文,实现者则要在每一种处理器上把那些条文翻译成正确的屏障指令;微软的团队为软件事务内存打磨了数年,从运行时、操作系统一路做到硬件指令,最终承认此路不通,整体放弃;Cilk 血统的工作窃取运行时反复重写,为的是把任务窃取的锁竞争压到最低。这些人承受的是被转移而非被消灭的复杂度——抽象把并行的困难从百万业务程序员身上卸下来,压到了千分之几的运行时作者身上,社会总账面上看是巨大的节省,对个体则是不折不扣的特区:他们离硅片最近,工伤也最重。微软内部代号 Midori 的研究项目甚至把并发安全做进了类型系统,让编译器在代码写下的那一刻拒绝数据竞争——这些探索大多没能变成产品,却一寸寸垫高了后来者脚下的地基。
第二联寄给业务程序员。那一则“18.6 秒改到 26.3 秒”的记录里,工程师后来花掉的调优时间远超当初写串行版本的全部工时;工业仿真领域的统计更有代表性——同样是 16 核机器,显式动力学的加速比能到 12.5 倍,稳态流体只有 4.2 倍,电磁仿真的程序干脆停留在 1.1 倍,几乎等于白买了十二个核。开源仿真软件的用户们则反复验证着同一条经验:核数增加到一定程度,加速曲线躺平,再往上加甚至变慢,因为域分解之后,跨核交换边界数据的通信开销开始压过并行计算的收益。翻过车的工程师后来把教训总结成动手前的三问:串行比例是多少,任务是访存密集还是计算密集,同步点能不能减少——三个问题的答案没有一条写在语言语法里,全部写在硬件手册里。买硬件的钱、等待结果的时间、以及那些从来没被分配出去的算力,都是这一联账单的支付方式。
第三联最隐性,付账的是机房与电网。低效的并行程序有一个共同的体貌:所有核心都显示忙碌,其中大半在自旋、重试、等锁、等一致性事务——利用率数字体面,有效功为零。仪表盘上的红色高热,一部分是真实的工作,另一部分是原地踏步的燃料消耗。数据中心为这些空转照常付电费、付冷却水,热的产出倒是分毫不差。免费午餐终结之后的算力扩张,每一步都伴随着这层隐形税率的浮动:并行写得越差,税越高,而绝大多数并行代码谈不上写得好。
于是看清了 2005 年之后架构演化的一条暗线:每一代新硬件都在给“并行通信”重新定价,而每一次定价都直接写进了软件的排布方式。缓存一致性协议把“整行”定为通信的最小单位,于是程序员按 64 字节对齐数据;NUMA 给跨插槽访问标出高价,于是程序员声明内存亲和;chiplet 把定价细化到封装内部,于是固件表里多了两到四个节点;GPU 的 SIMT 把线程间通信规则内化为调度行为,对分歧按串行化收税,于是数据按 32 个一组排队;集群把定价权交给消息传递接口与域分解,于是科学计算的代码里布满了显式的边界交换;Roofline 的集群版本则把高带宽内存、NVLink、InfiniBand 一层层画进同一张图,让通信带宽与算力平起平坐地成为屋顶。架构没有辜负并行,它只是诚实地把通信的价目表递了过来——签收的那支笔,握在每一个排布数据布局的程序员手里。
抽象与泄漏这条主线,在并行编程身上走到了最赤裸的一站。串行时代的抽象是一次成功的收购:硬件的流水线、乱序与缓存,被“顺序执行”这一个语义承诺整体买断,代价隐入机器内部,程序员拿到的是一份干净的假象。多核之后,物理拒绝再被收购——缓存行、内存距离、线程束的拓扑一次次顶穿抽象的封条,把语义和性能重新焊接在一起。多核十五年,并行编程没有变得像串行一样简单,原因不在工具稀缺,而在物理不再接受被掩盖:谁宣称并行已被驯服,他驯服的至多是正确性的一半,性能的另一半账单,永远留给离硅片最近的那个人。
第 056 章 开源运动:从自由起义到地缘供应链与 AI 危机
2024 年 3 月的最后一周,微软的 Postgres 开发者安德烈斯·弗罗因德(Andres Freund)在为一台 Debian 测试机做例行性能排查时,盯上了一组不该出现的数字:ssh 登录进程的 CPU 占用高得离谱,内存调试工具 Valgrind 报出无法解释的错误,sshd 的启动比记忆中慢了半秒左右。他顺藤摸瓜,把嫌疑锁定在 sshd 链接的一台压缩库上——liblzma,来自一个叫 XZ Utils 的项目。3 月 29 日,弗罗因德在开源安全邮件列表公开了他的发现:这个由志愿者维护了十几年的压缩工具,其 5.6.0 与 5.6.1 版本被人蓄意植入了针对 sshd 的后门,漏洞编号 CVE-2024-3094,危险评分 10.0,满分。
这不是一次普通的入侵。回溯调查很快拼出一条长达两年多的攻击链:一个化名“Jia Tan”的贡献者从 2021 年底开始提交补丁,用真实改进赢得信任,再借马甲账号在邮件列表上向原维护者施压,最终接过维护权,在 2024 年初埋下那两个装着恶意二进制的压缩包。弗罗因德盯住的半秒钟延迟,成了全球 Linux 基础设施在毫厘之间躲过一场“万能钥匙”级别的劫持的唯一线索。
半秒钟的异常,撬出的是四十年账本的封底。1983 年以来,一场从道德愤怒出发的运动,发明了把自由写进许可证的法律机器,建成了全球软件业事实上的地基;地基之上,云厂商靠它营利,国家靠它争夺定义权,AI 公司靠它发布模型。而这套地基的施工队,在绝大多数地段,是领不到工资的志愿者。账单的收件人很少出现在发布会上。他们的名字藏在依赖树的叶子节点上,藏在某个压缩库、某个加密库、某个日志解析器的维护者签名里;全世界的公司与政府每天调用他们的代码数十亿次,而他们在现实中的身份,可能是一名用业余时间顶住生产事故的中年程序员、一个把维护工作挤在深夜的研究生、一位接手了陌生项目的退休工程师。这个悖论如何生成、如何被一次次绕开、又如何在 2024 年被国家级攻击者当作武器——是本章要清点的账。自由软件运动给世界留下了一个最大的悖论:人类历史上规模最大、最成功的协作工程,恰好也是人类历史上规模最大、最无偿的劳动账单。
被拒绝的打印机与反向使用的版权
运动的起点小得近乎荒诞:一台卡纸的打印机。20 世纪 80 年代初,麻省理工学院人工智能实验室(MIT AI Lab)换了一台施乐激光打印机。旧款打印机的驱动附带源代码,斯托曼和同事们改过驱动,让它在卡纸时主动通知用户,实验室里的人不必一遍遍跑去查看。新款打印机没有附源代码。斯托曼恰好认识一位在施乐参与编写该驱动的前实验室同事,于是登门索要源码,对方答应考虑,随后反悔。一台机器的小毛病修不了,斯托曼却从中读出了一个大问题的雏形:当软件的所有者可以禁止你帮助自己的邻居,用户之间最朴素的互助关系就被法律切断了。这件事的每个细节都平凡得不足为外人道,斯托曼却在后来的几十年里反复讲述它,因为整个自由软件运动的道德直觉都能在这台打印机里找到原型:软件本可以是邻居间互相修补的手艺,而一纸所有权就足以终止这种互助。
在 1983 年,这种愤怒并不占据道德高地。彼时软件业的共识恰恰相反:1969 年 IBM 率先把软件从硬件附赠中拆出来单独收费,1983 年 AT&T 分拆和解协议到期后,UNIX 不再随源代码分发,一份授权要价 4 万美元。程序是公司的财产、源码是核心商业机密、付费是激励创新的必要条件——这套逻辑在商业上完全成立,而且正在创造一个繁荣的新产业。人工智能实验室自身也在瓦解:实验室的多名黑客出走成立公司,把实验室里免费流通的软件改造成专有产品出售。斯托曼后来回忆,他面对的选择要么是接受“道德上的自杀”,要么是为黑客文化的存续发明一套新制度。他选了后者,并把它命名为 GNU——“GNU's Not Unix”(GNU 不是 Unix)的递归缩写,目标是绕开 AT&T 的版权,从零重写一个完全自由的类 Unix 操作系统。1985 年,他发表《GNU 宣言》,同年成立自由软件基金会(Free Software Foundation, FSF)。
真正让这场运动不同于纯粹的道德呼吁的,是斯托曼的第二项发明。GNU 项目早期就吃了一次版权转移的亏:1985 年发布的 GNU Emacs 用了詹姆斯·高斯林(James Gosling)编写的部分代码,不久高斯林把版权卖给 UniPress 公司,后者威胁斯托曼停止分发,他被迫全部重写。教训清晰而惨痛——即使原作者最初愿意分享,版权一旦转移,自由就随之消失。道德呼吁挡不住版权转让,那就把版权法本身变成自由的锁:用户使用、修改、再发布软件的自由,不再寄希望于作者的善意,而是以版权条款的形式固定下来——任何衍生作品必须携带同样的授权继续发布。斯托曼给它起了个名字,Copyleft,词源是一张科幻爱好者社团的贴纸,上面写着“Copyleft,保留所有权利”的反话。1986 年,他在接受 Byte 杂志采访时把这件事的机锋挑明:“我们利用了软件版权法本身,来对抗整个现有的版权系统。”1989 年,第一版通用公共许可证 GPL 正式发布,把这套条款通用化——任何程序无需修改许可证文本即可采用;1991 年的 GPL v2 成了沿用至今的经典文本。
把 GNU 从纲领变成操作系统,是一场比宣言更漫长的消耗战。1983 年 9 月,斯托曼在 Usenet 新闻组上发出那份后来被反复引用的宣告帖,邀请各地黑客加入一个“仿制 Unix 而不使用任何 Unix 原始代码”的工程;1985 年 Emacs 编辑器发布,1980 年代后半,编译器与核心工具链陆续就位。工程真正的瓶颈是内核——名为 Hurd 的 GNU 内核因架构雄心过大而长期难产,这个缺口将在 1991 年由一个芬兰学生的作品补上。斯托曼面对的对手不只是商业公司,还有时间:人工智能实验室的 Lisp 机器战争把昔日同事分成 Symbolics 与 LMI 两个商业阵营,实验室的公共软件文化在两家的代码私有化竞赛中消耗殆尽。斯托曼后来反复陈述这段经历对他意味着什么:他反对的对象与其说是商业,不如说是一种关系——软件的所有者有能力插进用户与用户之间,让“帮助邻居”变成违法行为。自由软件的四项自由(自由地使用、研究、修改、再发布)就是针对这种关系设计的:只要四项自由不可剥夺,插在中间的所有者就永远无法把用户彼此隔开。
Copyleft 的法律机关值得拆开看。版权法的默认状态是“保留所有权利”:没有授权的人,连合法复制一份程序都做不到。GPL 反其道而行,大方地授予所有人使用、修改、再分发——甚至出售——的权利,只有一个附加条件:基于这份代码的衍生作品,必须整体以 GPL 发布。于是“自由”沿着代码的调用链向下传递:你用我的 GPL 代码,你的产品就传染上 GPL;你的用户拿到产品,就自动获得源码的权利。反对者给它起了个诛心之词——“传染性”。这张链路图是理解此后四十年一切冲突的底图:
版权法默认:未获授权 = 保留所有权利
│
┌─────────────────────┼──────────────────────┐
▼ ▼ ▼
GPL 代码 A 专有代码 B GPL 代码 A(同一份)
│ │ │
衍生 / 链接 独立重写 部署为网络服务
▼ ▼ ▼
衍生作品 A' 闭源产品 B' 托管服务 C'(SaaS)
【传染条款生效: 【无接触,相安 【法律盲区:服务
必须整体以 GPL 无事——版权法 从未被"分发"为
发布,源码公开】 管不到重写】 副本,GPL 触发
│ 条款不生效】
│ ▲
│ 2007 年 AGPLv3 第 13 条:
│ "网络交互视同分发"──补上此洞──┘
▼
"自由"沿调用链传递,直到有人找到一条不经过"复制"的通道
值得强调的是,在当时,GPL 的批评者同样占据着一片合理的阵地。微软副总裁克雷格·蒙迪(Craig Mundie)2001 年在纽约大学的演讲中系统抨击 GPL:传染条款会把 GPL 的义务渗入商业组合软件,抬高企业采用的风险;同一年,微软 CEO 史蒂夫·鲍尔默公开把 Linux 的传染性比作“癌症”。这些话在当时并非纯粹的竞争抹黑——任何一家靠软件授权营收的公司,把 GPL 代码混入自家产品确实意味着商业模式的自毁。GPL 用版权法锁住自由,也就意味着它动用了版权法最锋利的那一面。理想主义与法律机关互为表里:道德是燃料,传染条款是引擎。这架机器很快就要等来它的第一个超大规模验证场。
集市的秩序:一条邮件列表上的世界工厂
1991 年 9 月,赫尔辛基大学学生林纳斯·托瓦兹(Linus Torvalds)把一个只有一万多行代码的内核 0.01 版挂上网络,请陌生人帮忙测试。次年 2 月,他给这个玩具内核换上了 GPL v2——这一步在事后看是整个软件史上杠杆率最高的决定:托瓦兹放弃了用内核换钱的可能性,换来的是全球志愿劳动力的无限入场券。
《人月神话》的作者弗雷德里克·布鲁克斯(Frederick Brooks)在 1975 年断言:向进度落后的软件项目增加人手,只会让进度更加落后——沟通成本随人数平方增长,这是“布鲁克斯法则”。按此推论,数千名互不相识、没有工资、没有中央管理的志愿者共同编写一个操作系统内核,应当是一场灾难。Linux 恰恰成了这场预言最响亮的反例。埃里克·雷蒙(Eric S. Raymond)1997 年出版《大教堂与集市》,把集中管控的开发比作大教堂,把 Linux 式的互联网协作比作集市,并总结出托瓦兹实践中的“林纳斯法则”:足够多的眼睛,将使所有的错误都无所遁形。缺陷暴露的速度与眼睛的数量成正比——调试不再是瓶颈,而是免费的分布式质检。
雷蒙的文学化总结遮住了机制层面的三个关键设计,它们才是集市的承重结构。其一,发布策略:早发布、常发布。内核版本以天为单位滚动,每个用户都同时是测试者,反馈回路被压到最短。其二,模块正交化:托瓦兹把内核切分为驱动、文件系统、网络协议栈等子系统,子系统的修改互不牵连,贡献者只需要理解自己那一小块——沟通成本没有被消灭,而是被架构预先吸收了。其三,层级维护者模型:每个子系统有一名长期负责的维护者,补丁先经子系统维护者审查,再汇入托瓦兹的合并队列。金字塔没有工资,但有一套严密的信誉资本体系——谁的补丁质量高、响应快,谁就在邮件列表上积累声誉,被任命为维护者;维护者的裁决权不来自职位,而来自历史贡献的复利。布鲁克斯法则成立的边界条件是“沟通成本随人数增长且无架构隔离”,Linux 把第二个条件拆掉了,法则便失效了。
支撑这套集市秩序的,还有一件常被故事忽略的工具:版本控制。早期内核协作靠的是邮件列表里往来的一堆补丁包——谁改了哪一行、哪一版基于哪一版,全靠人脑与邮件存档对齐;规模一旦上到几十万行、几千名贡献者,补丁包就成了一笔还算不清的账。2002 年,托瓦兹让步,采用商业公司 BitMover 的版本控制工具 BitKeeper,条件是免费使用却不得逆向——一个自由的操作系统,把协作的地基押在了一份专有许可证上,这个矛盾在 2005 年爆发:BitMover 收回授权,社区一度退回用手工打包补丁的老路。托瓦兹的回应是亲自写一个替代品,两周内拿出了 Git 的第一个可用版本。Git 的关键不是“存版本”,而是分布式:每个开发者本地都有一份完整仓库与全部历史,分支与合并成了廉价操作,补丁包那种线性的、脆弱的传递方式被彻底取代。这套工具后来独自长成了地球上最广泛的代码协作基础设施——GitHub 在 2008 年把它包上网页界面,开源运动的协作规模由此从“几千人维护一个内核”扩展到“数百万人共同编织整个软件世界”。Linux 与 Git,是同一个人留下的两笔遗产:前者证明了集市能造出内核,后者给了集市一副能承载百万人协作的骨架。
托瓦兹的选择把两条线索拧在了一起:GNU 提供了操作系统全套的自由软件工具与许可证框架,唯独缺一颗能开机自举的内核;Linux 内核恰好补上这个缺口。1990 年代前中期,把内核、GNU 工具与桌面环境打包成完整可安装系统的发行版公司相继出现,Debian 与 Red Hat 是其中最著名的两家;围绕 Apache 网页服务器,一批分属不同公司的工程师建立了后来被称为“基金会治理”的协作范式。互联网服务器市场在世纪之交悄然换底,免费内核加自由工具的组合成了网页时代默认的底座。1998 年,微软内部评估 Linux 与开放源代码的备忘录被泄露到网上,因临近万圣节被称作“Halloween 文档”——文件承认 Linux 的开发模式构成现实威胁,并认真讨论了 GPL 传染条款对专有软件的杀伤;一家闭源巨头以内部研究的方式向对手致敬,这是集市收到的第一份敌方情报评估。此后的攻防沿两条轨道展开:市场轨道上,服务器与数据库厂商相继把 Linux 列入官方支持清单;舆论轨道上,从蒙迪 2001 年的演讲到鲍尔默把 GPL 比作“癌症”的指控,对传染条款的恐惧被反复动员。托瓦兹本人的姿态则是刻意反高潮:他反复声明自己关心的是工程效率而非意识形态,内核社区对政治保持距离。这种实用主义与斯托曼的道德绝对主义构成运动的两极,而两极之间的张力,恰恰是开源能同时被理想者与生意人接受的结构性原因。
集市的秩序也吸引来了它最重要的反对者们的回头。1998 年 1 月,网景(Netscape)为对抗微软的浏览器垄断,宣布公开网景浏览器源代码——一家身受闭源巨头压迫的商业公司,把开源当成了最后的武器。1998 年 2 月 3 日,加州帕洛阿尔托的一次策略会议上,克里斯廷·彼得森(Christine Peterson)提议用“open source”替代“free software”,理由很直接:free 在英文里同时是“自由”和“免费”,商业世界分不清两者,恐惧前者、喜爱后者;而“开源”听起来像一种更高效的工程方法,没有道德包袱。埃里克·雷蒙与布鲁斯·佩伦斯(Bruce Perens)随后创立开放源代码促进会(Open Source Initiative, OSI),把此前的 Debian 自由软件准则整理为“开源定义”,为这个词颁发认证。斯托曼拒绝出席这场改名运动,他的立场始终如一:开源讲的是开发模式的效率,自由软件讲的是用户的道德权利——后者才是运动的本体。这场分裂在字面上只是措辞之争,实际上为四十年后的定义之战埋好了引线:当“开源”成为一门利润与主权的生意,由谁来裁决谁配得上这个词,就成了权力本身。
商业力量的回头同样迅速。IBM 等硬件与服务业巨头发现,一个没有所有者的免费内核恰好能瓦解微软的操作系统税,于是纷纷投入 Linux 怀抱;1998 年《福布斯》封面报道 Linux,集市登上了主流商业媒体的封面。Red Hat 等发行版公司靠“免费软件加收费服务”活了下来,证明开源与生意可以兼容。但商业公司真正想要的,从始至终只是自己成本结构的优化,抽象的自由排不进账本——这个裂缝,要到云时代才会彻底裂开。在这之前的二十年里,地基上的每一块砖,仍然主要由志愿者亲手砌上,而付账的问题,被增长的奇迹暂时盖住了。
云的通道:被绕过的条款与无人付账的地基
许可证战争打赢了,战争的理由却在 2010 年代被悄悄抽空。云厂商发现了一条不需要触碰 GPL 条款就能免费装载开源成果的通道:把 MySQL、Redis、Elasticsearch 部署在自己的机房,以网络接口对外出售托管服务。用户拿到的从来不是软件副本,而是 API 的调用结果——GPL 的触发条款写的是“分发”,网络调用不属于分发,传染链条在服务边界前戛然而止。云厂商拿走了软件的全部价值,上游社区连一封转发来的故障工单都收不到。2007 年定稿的 AGPL v3 在第 13 条补上了这个洞——网络交互视同分发——但补丁只对事前声明采用它的项目有效,历史存量项目依然裸奔。一些大公司干脆把 AGPL 列入内部合规禁用清单,宁可不用,也不愿背上“提供服务即须公开整套服务栈”的义务。
开源公司的商业模式由此经历三代演进:红帽代表的 1.0 模式卖支持服务与发行版订阅;2.0 的 OpenCore 模式把核心开源、增值功能闭源;3.0 则与云平台深度绑定,收费随用量分成。每一代的共同前提都是:开源部分带来规模,闭源部分收回利润。当 AWS 这样的超大规模云厂商直接把开源产品的完整形态做成托管服务时,这个前提就断了——云厂商不修改代码,不侵犯许可证,只是比你更会运营你的软件。2018 年 10 月,MongoDB 宣布新版本弃用 AGPL,改用自己起草的 SSPL 许可证,要求任何向第三方提供该软件即服务的企业开源整套服务运维栈;开放源代码促进会随即裁定 SSPL 不是开源许可证——因为它对一类用户(云服务商)施加了歧视性条款。开源的定义权,第一次被商业公司主动放弃:MongoDB 的逻辑同样自洽——许可证的目的是保护用户自由,但当“用户”里最大的一家正在用你的免费劳动摧毁你的公司时,教条地坚持定义权等于自杀。
决裂此起彼伏,像一场按同一剧本排演的连续剧。2021 年 1 月,Elastic 公司把 Elasticsearch 与 Kibana 从 Apache 2.0 转为 SSPL 加自有许可的双许可,AWS 立即在 4 月基于最后一个 Apache 2.0 版本分叉出 OpenSearch;2024 年 3 月 20 日,Redis 放弃沿用十余年的 BSD 许可,转向 RSALv2 与 SSPLv1 双许可,Linux 基金会八天后就宣布了由 Google、AWS、Oracle 等云厂商联合背书的社区分叉 Valkey——云厂商用一个 fork 表明态度:你的代码我们照用,你的品牌不要也罢。剧情在 2025 年 5 月出现反转:Redis 首席执行官罗恩·特罗洛普(Rowan Trollope)在官方博客宣布 Redis 8 回归开源、采用 AGPLv3,公开承认超大规模云厂商的崛起改变了许可算术——分叉带走了社区,许可战打输了自己。这一轮撕裂没有赢家:上游公司失去了“开源”的名分,云厂商拿到了代码却坐实了“白嫖”的指控,而开源定义本身在反复的重新议价中暴露了它的本质——它与其说是道德律令,不如说是一份“用放弃专有控制换取事实标准”的交易合同,每一代人都在重新讨价还价。
连企业自身也学会了把许可证当武器。2010 年,Oracle 收购 Sun Microsystems,顺带接过 MySQL 的版权,社区随即分裂——原开发者以 MariaDB 为名分叉了 MySQL,办公套件社区同样以 LibreOffice 分叉了 OpenOffice.org;一家数据库巨头的收购案,演示了“版权集中在谁手里”这个 Copyleft 世界最脆弱的接缝。2023 年 8 月,基础设施自动化公司 HashiCorp 把 Terraform 改为限制商用的 BSL 许可,社区在数周内分叉出 OpenTofu——剧本已如此成熟,以至于每一次许可变更都自动触发一次分叉,分叉本身成了社区对公司反悔的民主否决权。把这一轮撕裂放回更长的视野,开源公司的商业摸索清晰可见:卖支持服务的红帽模式证明“免费代码、收费服务”可以撑起一家上市公司;OpenCore 模式把增值功能锁进闭源层;云绑定模式则把计费与用量挂钩。三代模式的共同前提是开源部分创造规模、闭源部分回收利润,而云厂商的托管服务恰好从中间截走了利润环。MongoDB 们转向 SSPL,算不上背弃开源,更像一次失败的自救:他们试图在不放弃“源码可得”的前提下,把“提供托管服务”从允许清单挪到禁止清单。OSI 拒绝为 SSPL 盖章,守住了定义的纯粹,也让这批公司从此只能顶着“源码可得”的次级名分经营——定义权的纯洁与商业公司的生存权,在这条裂缝两侧各自站队,没有中间地带。
当立法者们在许可证文本里缠斗时,地基本身的裂缝在无声扩大。2014 年 4 月,Google 安全团队的尼尔·梅塔(Neel Mehta)与芬兰安全公司 Codenomicon 独立发现,OpenSSL 心跳扩展里藏着一个内存越界读取:攻击者发送一个格式恶意的心跳请求,服务器就会把内存中任意 64 KB 的数据原样奉还,里面可能有 TLS 私钥、用户密码、会话票据。缺陷由博士生罗宾·赛格尔曼(Robin Seggelmann)2011 年实现心跳扩展时引入,经四位核心开发者之一史蒂芬·汉森(Stephen N. Henson)审查发布——审查者漏掉了那行缺失的边界检查。全球 HTTPS 服务器带着这个洞运行了两年,利用不留痕迹。机制上的荒诞值得一看:
/* 心跳请求处理示意(非原始代码):长度字段未被校验 */
int heartbeat(unsigned char *req, size_t req_len) {
unsigned int length = req[1]; /* 攻击者可声明至多 64KB */
unsigned char *resp = malloc(length);
/* 应当复制 min(length, req_len - 2) 字节,
实际代码直接按 length 复制——
而 req 缓冲区里可能只有 1 字节真实数据 */
memcpy(resp, req + 2, length);
send_back(resp, length); /* 内存残余随响应发出 */
return 0;
}
比漏洞更刺眼的是漏洞背后的账本。支撑着全球大部分加密通信、承载价值数十亿美元商业交易的 OpenSSL,由几名志愿者兼职维护,全职开发者只有一名;研究人员估算,一次 10 万美元的安全审计就足以发现这个缺陷,而这个项目每年收到的捐赠约为 2000 美元。事件震动了整个行业,Linux 基金会随即发起“核心基础设施计划”资助关键项目,后来演化为开源安全基金会(OpenSSF)。xkcd 在 2020 年画出了这个时代的自我画像:题为“依赖”的漫画里,所有现代数字基础设施压在一座孤岛上,岛上是一个从 2003 年起默默维护某个库的无名者——一封匿名威胁邮件就能让整个世界倾覆。漫画流传之广,恰恰说明每个人都认出了自己脚下的地基。
把 Heartbleed 与 xz 排在同一份账单上,会看清这张账单的结构。开源运动的生产函数里,劳动是免费的,而需求是刚性的:全世界对加密库与压缩库的依赖随互联网扩张线性增长,供给端的志愿者数量却由兴趣随机分布。只要“关键依赖”与“零报酬”的组合存在,就永远存在未经审计的代码路径,以及可以被耐心攻陷的岗位;许可证与基金会的资助只能覆盖数百个关键项目的一小部分,长尾部分依然靠兴趣和荣誉感发电,而兴趣和荣誉感恰恰是最不稳定的供给。这不是任何人的道德失败,而是公共品供给的经典难题在数字时代的复现——只是这一次,公共品的质量直接决定全球金融、医疗与政务系统的安全水位,也正因为如此,xz 攻击者的两年卧底才如此经济:社区自愿性提供的不仅是代码,还有信任,而信任是成本最低、验证最难的东西。
十年后,xz 事件把同一张账单又寄到了,这次附带攻击者的视角。拉斯·科林(Lasse Collin)自 2005 年起无偿维护 XZ Utils,不以此为业;2021 年底,“Jia Tan”带着看似无害的补丁出现,用一年半的真实贡献积累信誉;2022 年中,多个马甲账号开始在邮件列表施压——“当前维护者已不再感兴趣,也不愿继续维护。对这样一个仓库来说,实在令人遗憾”“我理解这是一个大家出于兴趣参与的项目,但社区有更高期望。为何不交出维护权呢”。这些话没有一句是假的:项目确实乏人问津,维护者确实分身乏术,社区确实有更高的期望。科林把越来越多的工作交给了这位“可靠的新人”,2023 年初对方发布了第一个官方版本,2024 年 2 月,后门进入了 5.6.0。Go 语言团队的核心开发者拉斯·考克斯(Russ Cox)在复盘里算清了这笔账:一名合格工程师全职卧底两年、骗取一个开源社区的信任,成本不超过一百万美元;利用代码再花一百万上下;而一旦得手,在互联网上大多数 Linux SSH 服务器里安插万能钥匙,价值以数十亿美元计。攻击成本与防御成本之间的这道鸿沟,瞄准的与其说是代码质量,不如说是劳动制度本身——一个关键岗位没有人付工资,迟早会被出价更高的人接管。这类社工剧本并非孤例:2018 年的 event-stream 事件里,攻击者接手一个流行 JavaScript 库的方式,只是礼貌地询问原作者是否愿意让贤,随后在更新中植入了窃取比特币的代码。安全研究者戴夫·艾特尔(Dave Aitel)认为手法符合俄罗斯对外情报局支持的黑客组织 APT29 的作案模式,亦有其他分析指向任何有资源的国家行为体——均无定论,但没有人怀疑这是国家级的耐心。计算机科学家亚历克斯·斯塔莫斯(Alex Stamos)在《纽约时报》的采访中断言:“这可能是植入任何软件产品的最广泛、最有效的后门”,若未被发现,“其创造者将握有运行 SSH 的全球数亿计算机的万能钥匙”。事件之后,OpenSSF 与 OpenJS 基金会联合警告这类社工夺权“可能不是孤立事件”,提醒维护者警惕那些“友好而激进、执着追求维护者身份”的陌生社区成员——一个行业开始把志愿者的热情当作国家级威胁指标来防范,这本身就是隐性账单最直白的物证:四十年理想主义的遗产清单上,最终出现了一行“警惕每一个免费帮忙的人”。
国界落下,权重飞散:定义之战(2020—2025)
2024 年 xz 事件让人看清了地基上最脆弱的一环是维护者,而 2019 年的一系列事件早已表明,地基本身也有一道国界。2019 年 5 月,美国把多家中国企业列入出口管制实体清单,GitHub 依据《出口管理条例》开始限制清单上的账号;7 月下旬,限制扩大到伊朗、叙利亚、克里米亚等受制裁地区的普通开发者,私人仓库与付费服务一并冻结。2020 年 4 月,一个名为 Aurelia 的开源项目因两名核心志愿者是伊朗人而遭到封锁,消息在 Hacker News 引爆,社区发现的荒谬之处在于机制:两名志愿者的账号被认定为受制裁地区主体,项目仓库因“与受限主体的协作”而整体受限——代码本身从未违反任何禁令,违反禁令的是贡献者的国籍与居住地。硅谷工程师们愤怒地质问:代码贡献何时成了受制裁的“服务”?GitHub 随后恢复了项目页面,仍封锁两名伊朗人的账号;2021 年初,它才获得美国财政部海外资产控制办公室的许可,恢复对伊朗开发者的部分服务。GitHub 的处境并非虚伪,而是结构性困境:一家加州公司运营着全球最大的代码托管平台,美国法律对它具有完整的域外效力——要么执行制裁,要么让整个平台在美国市场死亡。开源运动的奠基者们曾经相信协议与许可证可以构建一个不依赖国家权力的技术共同体,2019 年之后,这个共同体的每一行代码都托管在主权国家的司法管辖区之内。“代码无国界”没有说错,说错的是后半句——托管有国界,构建流水线有国界,分发渠道有国界。出口管制深入开源的另一面,是替代基础设施的萌生:受制裁的开发者与不愿把协作命脉交给单一司法管辖区的公司,开始建设镜像平台与区域代码托管;版本控制协议本身的开放,让“另建一个托管平台”在技术上可行,真正难以复制的是围绕平台的协作网络与信誉资产。开源的地基没有崩塌,但每一个依赖它的国家与公司都从此记住了同一件事:这条供应链虽然免费,却有闸门;闸门虽然很少落下,但毕竟落过。基础设施的开放承诺与法律的主权属性,从此长期共存于同一段代码的下载路径上。
如果说 GitHub 事件宣告了地缘政治入侵开源的基础设施,Meta 的 LLaMA 则把战场扩大到了“开源”这个词本身。2023 年 2 月 24 日,Meta 发布四档参数的大语言模型 LLaMA(70 亿至 650 亿参数),权重以“研究许可”定向提供给申请获批的研究机构——不开放下载,不可商用。发布不到一周,完整权重通过磁力链接泄露,被公开分享到 4chan 论坛;再过一周,开发者乔治·杰尔加诺夫(Georgi Gerganov)编写的纯 C/C++ 推理引擎 llama.cpp 让最小的 7B 模型在 MacBook 上本地运行。Meta 没有像传统版权方那样全力扑杀泄露——2023 年 7 月 18 日,它发布 Llama 2,直接开放了大多数商业部署(仅对月活超 7 亿的平台另行审批),等于把泄露造成的既成事实合法化,并顺势把自己塑造成生成式 AI 时代的开放旗手。它的算盘本来就有两层:定向发布保住对闭源对手的迟滞优势,研究社区则免费提供评测、优化与人才管道;泄露打乱了第一层,却意外放大了第二层。权重一旦在公开论坛流转、社区工具链一周内跟上,召回在技术上已不可能,商业上也不再必要。这是一笔精明的交易:大模型的核心资产不再是代码而是权重与算力,公开权重可以瓦解闭源对手的封闭生态,把全球开发者吸引到自己的技术栈周围——社区贡献、生态位、标准话语权,样样都朝着事实标准汇聚。而这份从容的底气来自权重的物理属性:一份权重文件一旦上网,复制它的边际成本趋近于零,世界上没有任何一种法律机制能在每个司法管辖区同时收回它。“开源”再一次被用作商业策略,和 1998 年网景的动机如出一辙,只是筹码从浏览器代码换成了数百亿参数。
但 AI 时代的“开源”与源代码时代的开源隔着一道本质裂缝。传统开源的定义锚点是源代码:拿到代码,你就拿到了全部。大模型的全部却由三部分构成——权重、训练代码、训练数据。Meta 们公开的只有权重:训练数据的数万亿词元来源不明,数据清洗代码不予公开,安全过滤的细节语焉不详。你可以下载权重、微调权重、本地部署权重,却无法复现这个模型,也无从审计它学过什么、带着哪些偏见与版权债务。2024 年 10 月 28 日,OSI 发布《开源人工智能定义 1.0》,试图延续四十年前的定义权威:开源 AI 必须满足使用、研究、修改、分享四项自由,并提供数据信息、代码、参数三要素——数据信息允许以详尽的来源说明替代数据本体。折中方案两头不讨好:激进开源阵营批评“不公开数据集就不算开源”,Meta 等工业界模型发布方则指出万亿词元数据的披露牵涉隐私、版权与安全,现实中最优就是开放权重加技术文档。这场激辩公开撕裂了 FOSS 社区,四十年前彼得森用“开源”收编理想主义的旧事,此刻以相反方向重演——这一次,理想主义者拒绝被收编。争论的实质是命名权。开放权重的发布普及了一种简单的期待:强大的模型应当可以本地测试、定制、部署在其创建者的云端之外——这确实是真实让渡的控制权,Meta 也一直以开源自我标榜;但许可证中的可接受使用条款、品牌使用限制与数据披露的缺失,让这种让渡与软件时代的开源之间隔着一整个法律时代。软件时代的开源定义用了四十年建立起一套可认证的边界,OSI 试图把它延伸到 AI,工业界则用既成事实倒逼边界后退——最终写进标准的每一个折中,都是一次权力的重新配比。
而地缘立法者已抢先落子:2025 年,美国商务部工业与安全局修订《出口管理条例》,将模型权重正式纳入管制物项,但例外条款明确——已公开发布的权重不予控制。换言之,官方监管口径把“公开”本身认定为不可逆的释放,开放权重在法律上获得了一种奇特的独立生命:一经发布,永久出境。开源运动的第四个十年,以一种它从未预料的方式收场:它当年发明的“自由分发”机制,如今成了国家出口管制体系里一个精心设计的例外条款。法学研究者把这套安排称作法律规制套利:2025 年起,美国与欧洲相继在法律上承认模型权重的独立实体地位,公开行为本身成了不可逆的释放——一家公司只要把权重上传到 Hugging Face 或 GitHub 这样的全球平台,管制从此无从落地。四十年前,斯托曼用 GPL 把代码的自由写进版权法,让“分发”触发义务;四十年后,各国立法者用出口管制的例外条款把“公开”写成了不可逆事件,让发布免除管制。两种法律发明遥相呼应,方向却完全相反:前者约束发布者必须保持开放,后者奖励发布者抢先开放——受益者都不再是传统意义上的用户自由,而是开放行为背后各自的竞争策略。
四个时代,三次重新议价。1980 年代,斯托曼用 GPL 完成第一次议价:专有软件阵营拿走了利润,自由软件阵营拿走了法律工具;1990 年代,商业公司完成第二次议价:拿走开源这个无道德包袱的名字,付出企业级支持与基金会治理的承诺;2010 年代,云厂商试图拒绝议价——直接取用,不作回报——于是有了 SSPL 与分叉的乱局;2020 年代,国家与 AI 资本各自开价:前者冻结账号、管制权重,后者用开放的品牌红利换取生态主导权。每一次议价,放弃专有控制的一方都相信自己换到了更值钱的东西——事实标准、开发者人心、历史正统性;而每一次议价的成本,都落在同一个地方:那些在邮件列表里无偿维护关键依赖的人。
回望 1983 年那台卡纸的打印机,斯托曼的愤怒指向一个具体的、可修复的不义:索要源码被拒,用户失去互助的能力。他为此发明了道德纲领与法律机器,机器运转四十年,建成了人类协作史上最庞大的公共工程,也把它的缔造者最不愿看到的三种力量先后引进了大门——把公共工程当作免费原料的云资本,把基础设施当作地缘筹码的民族国家,把“开放”当作营销话术的 AI 巨头。而这一切的全部成本底线,始终压在科林与赛格尔曼这样的无偿维护者身上:OpenSSL 每年 2000 美元的捐赠,xz 那个没人付工资的关键岗位,Heartbleed 潜伏两年的每一个深夜。开源运动最深刻的制度发明——用许可证把义务写进代码链路——恰恰暴露了它最深的制度空洞:义务可以传染,报酬不能。开源运动赢下了所有它参与的战争,却始终没能把“谁为维护者付账”写进任何一版许可证;于是每一次权力交接都精准地绕过最弱的一环——云厂商绕过条款,国家冻结账号,AI 巨头接管定义,而地基,仍由免费的人在免费地扛着。这枚硬币的两面必须同时看到:若不承认这种无偿劳动的公共品属性,它是地缘与资本博弈中最便宜的资源;若承认它,开源运动四十年的核心成就——把人类最关键的数字基础设施从商业合同与国家权力的双重私有领地中解放出来——就再没有一块基石是站得住的。这正是本书主线四在制度层的最终证词:标准与生态从来都是利益与主权的角力场,而开源,这个看起来最无国界、最无主权的制度实验,恰恰在地缘与资本的每个转角处,都收到了属于它自己的那份账单。
「计算机百年史」系列第 5 篇(共 10 篇)。全系列统一标签:计算机百年史。