本文永久链接 – https://tonybai.com/2025/10/18/lessons-from-java-26-years-evolution

大家好，我是Tony Bai。

历史不会简单重复，但总是惊人地相似。编程语言的演化，如同一部波澜壮阔的史诗，充满了智慧的闪光、艰难的抉择与深刻的教训。

上月，资深工程师 Neil Madden 发表了一篇引人入胜的文章《点评 26 年的 Java 变更》，以一位亲历者的视角，犀利地回顾了这门“常青”语言的演进之路。

注：Neil Madden口中的Java 26年是指自他1999年学习Java编程开始到2025年的今天。

从Gopher视角来看，这并非一篇简单的技术评论，而是一次宝贵的以史为鉴的机会。

Java 作为企业级开发的“前浪”，其三十年的漫长的发展历程就像一本厚重的教科书，记录了在引入泛型、改进 I/O、简化并发等几乎所有重大议题上的探索与挣扎。

对于 Go 语言乃至整个软件工程领域而言，这其中蕴含着超越语言本身的普适性启示。本文并非旨在对比 Go 与 Java 的优劣，而是希望作为一部“技术沉思录”，通过 Java 这个案例，与各位一同探寻编程语言演进的内在规律。

启示一：核心特性的引入，时机与设计的艺术

Java 5 (2004) – 泛型 (Generics)

“as Go discovered on its attempt to speed-run Java’s mistakes all over again, if you don’t add generics from the start then you’ll have to retrofit them later, badly.”
（正如 Go 在其“快速重蹈 Java 覆辙”的尝试中发现的那样，如果你不从一开始就加入泛型，那么日后就不得不糟糕地进行弥补。）

Java 直到发布 8 年后才引入泛型。为了保持对海量存量代码的向后兼容性，它做出了一个影响深远的妥协：类型擦除 (type erasure)。这个决定虽然在当时解决了燃眉之急，却也带来了诸多“粗糙的边缘”，如反射处理困难、无法对泛型类型进行 instanceof 判断等，至今仍是 Java 开发者的痛点。

由此看来，语言核心特性的引入，是一场关于时机与设计的精妙艺术。过早引入，可能因设计不成熟而留下历史包袱；过晚引入，则必然会受到向后兼容性的掣肘，导致实现上的妥协。Java 的经验深刻地揭示了“后补”式设计的代价。

Go 语言在发布 12 年后才于1.18 版本引入泛型，同样面临巨大的兼容性压力。幸运的是，Go 团队得以借鉴 Java 的教训，选择了一条更艰难但更正确的道路——结合”Stenciling方案”和”Dictionaries方案”的“GC Shape Stenciling 方案”，在编译时间(二进制文件膨胀)以及运行时开销方面做了一个折中，并且没有类型擦除。这为 Go 泛型的未来发展奠定了更坚实的基础，也印证了一个原则：对于动摇语言根基的核心特性，宁愿慢，也要做对。

注：关于Go泛型实现机制的详细说明，请参见极客时间《Go语言第一课》的第41讲《驯服泛型：明确使用时机》。

启示二：API 是语言的“遗产”，其影响远超想象

Java 1.4 (2002) – “New” I/O (NIO)

“Provided non-blocking I/O for the first time, but really just a horrible API… Has barely improved in 2 and a half decades.”
（首次提供了非阻塞 I/O，但 API 简直糟透了……在 25 年里几乎没有任何改进。）

Neil 对 Java NIO 的评价毫不留情。他吐槽其 API 令人困惑，并且 inexplicably（莫名其妙地）使用 32 位有符号整数表示文件大小，将文件限制在 2GB 以内，这成为了 Java I/O 长期以来的一个“历史污点”。

这也印证了这样一条结论：标准库的 API 一旦发布，就成为语言最宝贵也最沉重的“遗产”。

一个设计精良的 API 可以赋能一代又一代的开发者，而一个糟糕的 API 则可能成为数十年都难以摆脱的枷锁。它定义了开发者与语言交互的方式，深刻地影响着生产力、代码质量和开发者的心智模型。

Go 语言从诞生之初就拥有一个设计极其精良的 I/O 模型。io.Reader 和 io.Writer 接口的简洁与强大，至今仍是语言设计的典范。Go 的网络库 net 基于操作系统提供的非阻塞 I/O（如 epoll），并通过 goroutine 将其巧妙地封装为同步阻塞的编程模型。这使得 Go 开发者既能享受非阻塞 I/O 的高性能，又无需陷入复杂的回调地狱。Java NIO 的“失误”深刻地提醒我们，在 API 设计上投入再多的思考也不为过。

启示三：将正确的并发模型内置于语言，是生产力的巨大飞跃

Java 5 (2004) – java.util.concurrent
Java 19 (2022) – 虚拟线程 (Virtual Threads)

Neil 对 Doug Lea 的 java.util.concurrent (J.U.C) 包给予了满分盛赞，认为其设计极其出色。然而，他也指出，在苦苦挣扎于各种复杂的异步编程模型多年后，Java 才终于通过 Project Loom 引入了虚拟线程，试图在 JVM 层面实现 M:N 的轻量级并发模型。

并发是现代软件开发的基石。一种语言如何处理并发，直接决定了其生产力的上限。Java 的演进路径——先提供一套强大的、专家级的底层并发工具（J.U.C），然后在多年后才引入一个更高层次、更易于大众使用的并发模型（虚拟线程）——揭示了一条从“提供工具”到“提供模型”的演进规律。

Go 语言在这一点上扮演了“预言家”的角色。它从诞生之初就将轻量级并发 (goroutine) 和 通信 (channel) 作为语言的一等公民内置于运行时。这种 CSP (Communicating Sequential Processes) 模型，极大地简化了并发编程的心智负担。Go 的成功雄辩地证明了，将一个简单、强大的并发模型作为语言的核心特性，其带来的生产力飞跃，远非一个复杂的工具箱所能比拟。

启示四：警惕范围蔓延，敬畏生态兼容性

Java 8 (2014) – Streams API
Java 9 (2017) – 模块系统 (Modules)

Neil 对 Java Streams API 和模块系统给出了惊人的低分。他认为，Streams API 为了实现“看似简单”的并行计算而过度设计，变得复杂难用。而模块系统（Project Jigsaw）虽然初衷是解决 JAR 地狱，但其引入的巨大动荡和对现有生态的破坏性，使其得不偿失。

语言的演进充满了诱惑。一个好的特性，可能会因为被赋予了过多不相关的目标（范围蔓延）而变得臃肿不堪。任何试图“修正”语言底层生态的重大变革，都必须对生态兼容性抱有最大的敬畏。因为语言的生命力，最终源于其繁荣的社区和生态。

Go 在这方面也并非一帆风順。Go Modules 在诞生之初也曾引发巨大争议，但最终凭借其相对简洁的设计和 go 命令的强大集成能力，成功地统一了 Go 的依赖管理生态，其过程虽然有阵痛，但避免了 Java 模块系统那样的“大分裂”。Java 的这两个案例，为 Go 未来的任何重大变革都敲响了警钟。

小结：在巨人的肩膀上，继续沉思

回顾 Java 26 年的演进史，我们看到的不是一个失败者，而是一个不断自我革新、虽有失误但仍充满生命力的“巨人”。它的每一步探索，无论是成功还是失败，都为后来的语言（尤其是 Go）提供了宝贵的“启示录”。

Go 的幸运在于，它诞生得更晚，可以在“巨人的肩膀上”看得更远，从而在泛型、I/O 模型和并发等核心问题上，做出了更符合时代需求的设计。

然而，历史的镜子也照向未来。Go 如今也面临着自己的“沉思时刻”：如何平衡语言的简洁性与日益增长的表达力需求？如何演进标准库以适应新的挑战（这方面math/v2、json/v2做出了表率）？如何引入下一个可能具有破坏性的重大变革？

Java 的故事告诉我们，语言的演进是一场永无止境的马拉松。唯有保持谦逊，以史为鉴，并始终将开发者的真实需求和语言的内在哲学放在首位，才能在这场长跑中行稳致远。

资料链接：https://neilmadden.blog/2025/09/12/rating-26-years-of-java-changes/

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

本文永久链接 – https://tonybai.com/2025/10/15/go-archaeology-defer

大家好，我是Tony Bai。

在 Go 语言的所有关键字中，defer 无疑是最具特色和争议的之一。它以一种近乎“魔法”的方式，保证了资源清理逻辑的执行，极大地提升了代码的可读性和健壮性。f, _ := os.Open(“…”); defer f.Close() 这一行代码，几乎是所有 Gopher 的肌肉记忆。

然而，在这份优雅的背后，曾几何时，defer 却背负着“性能杀手”的恶名。在 Go 的历史长河中，无数资深开发者，包括标准库的维护者们，都曾被迫在代码的可维护性与极致性能之间做出痛苦的抉择，含泪删掉 defer 语句，换上丑陋但高效的手动 if err != nil 清理逻辑。

你是否好奇：

• defer 的早期实现究竟“慢”在哪里？为什么一个简单的函数调用会被放大数十倍的开销？
• 从 Go 1.13 到 Go 1.14，Go 团队究竟施展了怎样的“魔法”，让 defer 的性能提升了超过 10 倍，几乎达到了与直接调用函数相媲美的程度？
• 为了实现这场“性能革命”，defer 在编译器和运行时层面，经历了怎样一场从“堆分配”到“栈上开放编码(open-coded defer)”的“心脏手术”？

今天，就让我们再一次化身“Go 语言考古学家”，在Go issues以及Go团队那些著名的演讲资料中挖掘，并结合 Go 官方的设计文档，深入 defer 性能演进的“地心”，去完整地再现这场波澜壮阔的“救赎之路”。

“事后”的智慧：Defer 的设计哲学与独特性

在我们深入 defer 性能的“地心”之前，让我们先花点时间，站在一个更高的维度，欣赏一下 defer 这个语言构造本身的设计之美。defer机制 并非 Go 语言的首创，许多语言都有类似的机制来保证资源的确定性释放，但Go中defer 机制的实现方式却独树一帜，充满了 Go 语言独有的哲学。

保证“清理”的殊途同归

下面是几种主流语言的资源管理范式，这让我们能更清晰地看清 defer 的坐标：

• C++ 的 RAII (Resource Acquisition Is Initialization):

这是一种极其强大和高效的范式。资源（如文件句柄、锁）的生命周期与一个栈上对象的生命周期绑定。当对象离开作用域时，其析构函数 (destructor) 会被编译器自动调用，从而释放资源。RAII 的优点是静态可知、零运行时开销。但它强依赖于 C++ 的析构函数和对象生命周期管理，对于一门拥有垃圾回收（GC）的语言来说，这种模式难以复制。

• Java/Python 的 try-finally:

这是另一种常见的保证机制。finally 块中的代码，无论 try 块是正常结束还是抛出异常，都保证会被执行。try-finally 同样是静态可知的，编译器能明确地知道在每个代码块退出时需要执行什么。

这两种机制的共同点是：它们都是块级 (block-level) 的，并且清理逻辑的位置往往与资源获取的位置相距甚远。

Defer 的三大独特优势

相比之下，Go 的 defer 提供了三种独特的优势，使其在代码的可读性和灵活性上脱颖而出：

1. 就近原则，极致清晰 (Clarity):

这是 defer 最为人称道的优点。清理逻辑（defer f.Close()）可以紧跟在资源获取逻辑（os.Open(…)）之后。这种“开闭成对”的书写方式，极大地降低了程序员的心智负担，你再也不用在函数末尾的 finally 块和函数开头的资源申请之间来回跳转，从而有效避免了忘记释放资源的低级错误。

1. 函数级作用域，保证完整性 (Robustness):

defer 的执行时机与函数（而非代码块）的退出绑定。这意味着，无论函数有多少个 return 语句，无论它们分布在多么复杂的 if-else 分支中，所有已注册的 defer 调用都保证会在函数返回前被执行。这对于重构和维护极其友好——你可以随意增删 return 路径，而无需担心破坏资源清理的逻辑。更重要的是，在 panic 发生时，defer 依然会被执行，这为构建健壮的、能从异常中恢复的常驻服务提供了坚实的基础。

1. 动态与条件执行，极致灵活 (Flexibility):

这是 defer 与 RAII 和 try-finally 最本质的区别。defer 是一个完全动态的语句，它可以出现在 if 分支、甚至 for 循环中。

if useFile {
    f, err := os.Open("...")
    // ...
    defer f.Close() // 只在文件被打开时，才注册清理逻辑
}

这种条件式清理的能力，是其他静态机制难以优雅表达的。

“动态”的双刃剑

然而，defer 的动态性也是一把双刃剑。

正是因为它可以在循环中被调用，defer 在理论上可以被执行任意多次。编译器无法在编译期静态地知道一个函数到底会注册多少个 defer 调用。

这种不确定性，迫使 Go 的早期设计者必须借助运行时的帮助，通过一个动态的链表来管理 defer 调用栈。这就引出了我们即将要深入探讨的核心问题——为了这份极致的灵活性和清晰性，defer 在诞生之初，付出了怎样的性能代价？而 Go 团队又是如何通过一场载入史册的编译器革命，几乎将其“抹平”的？

现在，让我们带上“考古工具”，正式开始我们的性能探源之旅。

“原罪”：Go 1.13 之前的 defer 为何如此之慢？

在GopherCon 2020上，Google工程师Dan Scales为大家进行了一次经常的有关defer性能提升的演讲，在此次演讲中，他先为大家展示了一张令人震惊的性能对比图，也揭示了一个残酷的事实：在 Go 1.12 及更早的版本中，一次 defer 调用的开销高达 44 纳秒，而一次普通的函数调用仅需 1.7 纳秒，相差超过 25 倍！

这巨大的开销从何而来？答案隐藏在早期的实现机制中：一切 defer 都需要运行时（runtime）的深度参与，并且都涉及堆分配（heap allocation）。

让我们通过 Go 团队的内部视角，来还原一下当时 defer 的工作流程：

1. 创建 _defer 记录： 每当你的代码执行一个 defer 语句时，编译器会生成代码，在堆上分配一个 _defer 结构体。这个结构体就像一张“任务卡”，记录了要调用的函数指针、所有参数的拷贝，以及一个指向下一个 _defer 记录的指针。

1. deferproc 运行时调用： 创建好“任务卡”后，程序会调用运行时的 runtime.deferproc 函数。这个函数负责将这张新的“任务卡”挂载到当前 goroutine 的一个链表上。这个链表，我们称之为“defer 链”。

1. deferreturn 运行时调用： 当函数准备退出时（无论是正常 return 还是 panic），编译器会插入一个对 runtime.deferreturn 的调用。这个函数会像“工头”一样，从 defer 链的尾部开始（后进先出 LIFO），依次取出“任务卡”，并执行其中记录的函数调用。

看到了吗？每一次 defer，都至少包含：

• 一次堆内存分配（创建 _defer 记录）。
• 两次到运行时的函数调用 (deferproc 和 deferreturn)。

堆分配本身就是昂贵的操作，因为它需要加锁并与垃圾回收器（GC）打交道。而频繁地在用户代码和 runtime 之间切换，也带来了额外的开销。正是这“三座大山”，让 defer 在高性能场景下变得不堪重负。

Go 1.13 迈出了优化的第一步：对于不在循环中的 defer，编译器尝试将 _defer 记录分配在栈上。这避免了堆分配和 GC 的压力，使得 defer 的开销从 44ns 降低到了 32ns。这是一个显著的进步，但离“零成本”的目标还相去甚甚远。defer 依然需要与 runtime 交互，依然需要构建那个链表。

“革命”：Go 1.14 的 Open-Coded Defer

Go 1.14 带来的，不是改良，而是一场彻底的革命。Dan Scales 和他的同事们提出并实现了一个全新的机制，名为 “开放编码的 defer (Open-Coded Defer)”。

其核心思想是：对于那些简单的、非循环内的 defer，我们能不能彻底摆脱 runtime，让编译器直接在函数内生成所有清理逻辑？

答案是肯定的。这场“革命”分为两大战役：

战役一：在函数退出点直接生成代码

编译器不再生成对 deferproc 的调用。取而代之的是：

1. 栈上“专属”空间： 在函数的栈帧（stack frame）中，为每个 defer 调用的函数指针和参数预留“专属”的存储位置。
2. 位掩码（Bitmask）： 同样在栈上，引入一个 _deferBits 字节。它的每一个 bit 位对应一个 defer 语句。当一个 defer 被执行时，不再是创建 _defer 记录，而是简单地将 _deferBits 中对应的 bit 位置为 1。这是一个极快、极轻量的操作。

当函数准备退出时，编译器也不再调用 deferreturn。它会在每一个 return 语句前，插入一段“开放编码”的清理逻辑。这段逻辑就像一个智能的“清理机器人”，它会逆序检查 _deferBits 的每一位。如果 bit 位为 1，就从栈上的“专属空间”中取出函数指针和参数，直接发起调用：

看到了吗？在正常执行路径下，整个过程没有任何堆分配，没有任何 runtime 调用！defer 的成本，被降低到了几次内存写入（保存参数和设置 bit 位）和几次 if 判断。这使得其开销从 Go 1.13 的 32ns 骤降到了惊人的 3ns，与直接调用函数（1.7ns）的开销几乎在同一个数量级！

战役二：与 panic 流程的“深度整合”

你可能会问：既然没有 _defer 链表了，当 panic 发生时，runtime 怎么知道要执行哪些 defer 呢？

这正是 Open-Coded Defer 设计中最精妙、也最复杂的部分。Go 团队通过一种名为 funcdata 的机制，在编译后的二进制文件中，为每个使用了 Open-Coded Defer 的函数，都附上了一份“藏宝图”。

这份“藏宝图”告诉 runtime：

• 这个函数使用了开放编码。
• _deferBits 存储在栈帧的哪个偏移量上。
• 每个 defer 调用的函数指针和参数，分别存储在栈帧的哪些偏移量上。

当 panic 发生时，runtime 的 gopanic 函数会扫描 goroutine 的栈。当它发现一个带有 Open-Coded Defer 的栈帧时，它就会：

1. 读取这份“藏宝图” (funcdata)。
2. 根据“藏宝图”的指引，在栈帧中找到 _deferBits。
3. 根据 _deferBits 的值，再从栈帧中找到并执行所有已激活的 defer 调用。

这个设计，巧妙地将 defer 的信息编码在了栈帧和二进制文件中，使得 panic 流程依然能够正确地、逆序地执行所有 defer，同时保证了正常执行路径的极致性能。

下面是Dan Scales给出的一个defer性能对比结果：

我们看到：采用Open-coded defer进行优化后，defer的开销非常接近与普通的函数调用了(1.x倍)。

小结：“救赎”的完成与新的约定

defer 的性能“救赎之路”，从 Go 1.12 的 44ns，到 Go 1.13 的 32ns（栈分配 _defer 记录），再到 Go 1.14 的 3ns（Open-Coded Defer），其演进历程波澜壮阔，是 Go 团队追求极致性能与工程实用性的最佳例证。

下面是汇总后的各个Go版本的defer实现机制与开销数据：

这场“革命”之后，Dan Scales 在演讲的最后发出了强有力的呼吁，这也应该成为我们所有 Gopher 的新共识：

“defers should now be used whenever it makes sense to make code clearer and more maintainable. defer should definitely not be avoided for performance reasons.”
（现在，只要能让代码更清晰、更易于维护，就应该使用 defer。绝对不应该再因为性能原因而避免使用 defer。）

defer 的“原罪”已被救赎。从现在开始，请放心地使用它，去编写更优雅、更健壮的 Go 代码吧。

参考资料

• Proposal: Low-cost defers through inline code, and extra funcdata to manage the panic case – https://go.googlesource.com/proposal/+/master/design/34481-opencoded-defers.md
• GopherCon 2020: Implementing Faster Defers by Dan Scales – https://www.youtube.com/watch?v=DHVeUsrKcbM
• cmd/compile: allocate some defers in stack frames – https://github.com/golang/go/issues/6980

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。